{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e6a7f490-a243-4d83-8235-0797efff9f57",
   "metadata": {},
   "source": [
    "# 2.案例实战 - 用户评论情感分析¶"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "089807c3-8c6e-4150-ad3a-134f2591b96a",
   "metadata": {},
   "source": [
    "## 数据加载与探索"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "79a3f6a7-86f5-4a93-9403-80a13de04794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================================================================\n",
      "用户评论情感分析 - 完整版\n",
      "================================================================================\n",
      "\n",
      "=== 步骤1：数据加载和探索 ===\n",
      "数据形状: (1080, 3)\n",
      "\n",
      "数据前5行:\n",
      "   客户编号                                                 评论  评价\n",
      "0     1  是iPhone8 XR正品，按键屏幕反应蛮快的很灵活，屏幕6.0的不算很大，刚刚好，这款面容...   1\n",
      "1     2  外形外观：外光非常漂亮，黑色的非常大气。适合男士拥有。屏幕音效：刚开机就下载了一个QQ音乐试...   1\n",
      "2     3  从苹果4s，到6s，再到xr，就是喜欢苹果的手感和风格，视频流畅，图片清晰，纠结了好久买哪个...   1\n",
      "3     4  主要是手感，太沉了，比苹果6，沉一倍，厚太多了，看中双卡双待机，刚买回来用，待机时间还不错，...   1\n",
      "4     5  外形外观：红色超级好看，送妈妈的。屏幕音效：音效还可以，也什么特别的，屏幕看着也挺舒服。拍照...   1\n",
      "\n",
      "数据基本信息:\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 1080 entries, 0 to 1079\n",
      "Data columns (total 3 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   客户编号    1080 non-null   int64 \n",
      " 1   评论      1080 non-null   object\n",
      " 2   评价      1080 non-null   int64 \n",
      "dtypes: int64(2), object(1)\n",
      "memory usage: 25.4+ KB\n",
      "\n",
      "评价分布:\n",
      "评价\n",
      "1    600\n",
      "0    480\n",
      "Name: count, dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import jieba\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# 设置中文显示\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "print(\"=\"*80)\n",
    "print(\"用户评论情感分析 - 完整版\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "# ==================== 步骤1：数据加载和探索 ====================\n",
    "print(\"\\n=== 步骤1：数据加载和探索 ===\")\n",
    "\n",
    "# 读取数据\n",
    "df = pd.read_excel('产品评价.xlsx')\n",
    "print(f\"数据形状: {df.shape}\")\n",
    "print(\"\\n数据前5行:\")\n",
    "print(df.head())\n",
    "\n",
    "print(\"\\n数据基本信息:\")\n",
    "df.info()\n",
    "\n",
    "print(\"\\n评价分布:\")\n",
    "print(df['评价'].value_counts())\n",
    "\n",
    "# 可视化评价分布\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.subplot(1, 2, 1)\n",
    "df['评价'].value_counts().plot(kind='bar', color=['skyblue', 'lightcoral'])\n",
    "plt.title('评价分布')\n",
    "plt.xlabel('评价类型')\n",
    "plt.ylabel('数量')\n",
    "plt.xticks(rotation=0)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "df['评价'].value_counts().plot(kind='pie', autopct='%1.1f%%', colors=['skyblue', 'lightcoral'])\n",
    "plt.title('评价比例')\n",
    "plt.ylabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11f26a59-0e91-455f-bf3d-04d1305fd110",
   "metadata": {},
   "source": [
    "## 文本预处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9207e077-3a8b-4b38-a601-6a5d2f634fd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤2：文本预处理 ===\n",
      "第一条评论示例:\n",
      "是iPhone8 XR正品，按键屏幕反应蛮快的很灵活，屏幕6.0的不算很大，刚刚好，这款面容识别开锁比指纹方便多了，内外的整体看起来很美观，整机子不算是很厚感，像素高比较清晰，双卡双待，续航强，跟8plus差价300元，还是选XR款好，性能不错，处理器、芯片也是最新一代\n",
      "正在清洗文本...\n",
      "\n",
      "清洗前后对比:\n",
      "原文: 是iPhone8 XR正品，按键屏幕反应蛮快的很灵活，屏幕6.0的不算很大，刚刚好，这款面容识别开锁比指纹方便多了，内外的整体看起来很美观，整机子不算是很厚感，像素高比较清晰，双卡双待，续航强，跟8plus差价300元，还是选XR款好，性能不错，处理器、芯片也是最新一代\n",
      "清洗后: 是iPhone XR正品 按键屏幕反应蛮快的很灵活 屏幕 的不算很大 刚刚好 这款面容识别开锁比指纹方便多了 内外的整体看起来很美观 整机子不算是很厚感 像素高比较清晰 双卡双待 续航强 跟 plus差价 元 还是选XR款好 性能不错 处理器 芯片也是最新一代\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n=== 步骤2：文本预处理 ===\")\n",
    "\n",
    "# 查看第一条评论\n",
    "print(\"第一条评论示例:\")\n",
    "print(df.iloc[0]['评论'])\n",
    "\n",
    "# 文本清洗函数\n",
    "def clean_text(text):\n",
    "    \"\"\"清洗文本，去除特殊字符和数字\"\"\"\n",
    "    import re\n",
    "    # 保留中文、英文和基本标点\n",
    "    text = re.sub(r'[^\\u4e00-\\u9fa5a-zA-Z]', ' ', str(text))\n",
    "    # 去除多余空格\n",
    "    text = re.sub(r'\\s+', ' ', text).strip()\n",
    "    return text\n",
    "\n",
    "# 应用文本清洗\n",
    "print(\"正在清洗文本...\")\n",
    "df['clean_comment'] = df['评论'].apply(clean_text)\n",
    "\n",
    "# 查看清洗效果\n",
    "print(\"\\n清洗前后对比:\")\n",
    "print(f\"原文: {df.iloc[0]['评论']}\")\n",
    "print(f\"清洗后: {df.iloc[0]['clean_comment']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6b0c780-edb8-4fa1-ae2c-b51ea462bf8f",
   "metadata": {},
   "source": [
    "## 中文分词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9685b1f6-1ef7-4f7f-a0bb-352f80decb27",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\27855\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤3：中文分词 ===\n",
      "分词示例: 是iPhone XR正品 按键屏幕反应蛮快的很灵活 屏幕 的不算很大 刚刚好 这款面容识别开锁比指纹方便多了 内外的整体看起来很美观 整机子不算是很厚感 像素高比较清晰 双卡双待 续航强 跟 plus差价 元 还是选XR款好 性能不错 处理器 芯片也是最新一代\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 1.218 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "分词结果: 是 iPhone   XR 正品   按键 屏幕 反应 蛮快 的 很 灵活   屏幕   的 不算 很大   刚刚 好   这 款 面容 识别 开锁 比 指纹 方便 多 了   内外 的 整体 看起来 很 美观   整机 子 不算 是 很厚感   像素 高 比较 清晰   双卡 双待   续航 强   跟   plus 差价   元   还是 选 XR 款好   性能 不错   处理器   芯片 也 是 最新 一代\n",
      "正在对所有评论进行分词...\n",
      "已处理 100/1080 条评论\n",
      "已处理 200/1080 条评论\n",
      "已处理 300/1080 条评论\n",
      "已处理 400/1080 条评论\n",
      "已处理 500/1080 条评论\n",
      "已处理 600/1080 条评论\n",
      "已处理 700/1080 条评论\n",
      "已处理 800/1080 条评论\n",
      "已处理 900/1080 条评论\n",
      "已处理 1000/1080 条评论\n",
      "分词完成！\n",
      "\n",
      "分词结果示例:\n",
      "1. 是 iPhone   XR 正品   按键 屏幕 反应 蛮快 的 很 灵活   屏幕   的 不算 很大   刚刚 好   这 款 面容 识别 开锁 比 指纹 方便 多 了   内外 的 整体 看起来 很 美观   整机 子 不算 是 很厚感   像素 高 比较 清晰   双卡 双待   续航 强   跟   plus 差价   元   还是 选 XR 款好   性能 不错   处理器   芯片 也 是 最新 一代\n",
      "2. 外形 外观   外光 非常 漂亮   黑色 的 非常 大气   适合 男士 拥有   屏幕 音效   刚 开机 就 下载 了 一个 QQ 音乐 试 了 一下   音效 还是 非常 不错 的   拍照 效果   拍照 很 清晰   照亮 你 脸上 的 痘痘   运行 速度   运行 速度 就 不用说 了   一个 字快   待机时间   待机 很 不错   用 一段时间 再 来 评价   其他 特色   个人感觉 比   好   可能 是因为 上手 的 手感 比较 好 吧   总之 还是 值得 入手 的\n",
      "3. 从 苹果   s   到   s   再 到 xr   就是 喜欢 苹果 的 手感 和 风格   视频 流畅   图片 清晰   纠结 了 好久 买 哪个 颜色   白色 干净   同事 买 的 黄色   感觉 也 很 好看   蓝色   珊瑚 我 也 喜欢   最终 还是 选择 比较 适合 女生 的 珊瑚 色   实物 比 图片 更 漂亮   超级 喜欢   运行 速度 快   全屏 显示   体积小 了   可 显示 区域 变得 了   很棒\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n=== 步骤3：中文分词 ===\")\n",
    "\n",
    "# 演示分词效果\n",
    "sample_text = df.iloc[0]['clean_comment']\n",
    "print(f\"分词示例: {sample_text}\")\n",
    "words = jieba.cut(sample_text)\n",
    "print(\"分词结果:\", ' '.join(words))\n",
    "\n",
    "# 对所有评论进行分词\n",
    "print(\"正在对所有评论进行分词...\")\n",
    "words_list = []\n",
    "for i, row in df.iterrows():\n",
    "    words = jieba.cut(row['clean_comment'])\n",
    "    result = ' '.join(words)\n",
    "    words_list.append(result)\n",
    "    \n",
    "    if (i + 1) % 100 == 0:\n",
    "        print(f\"已处理 {i + 1}/{len(df)} 条评论\")\n",
    "\n",
    "print(\"分词完成！\")\n",
    "\n",
    "# 查看分词结果\n",
    "print(\"\\n分词结果示例:\")\n",
    "for i in range(min(3, len(words_list))):\n",
    "    print(f\"{i+1}. {words_list[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c575c8e-2d99-4ce3-a6a9-daf99f5a2a24",
   "metadata": {},
   "source": [
    "## 特征工程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7ec13606-f41f-43e3-947e-e5deb1327b0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤4：特征工程 ===\n",
      "方法1：使用词袋模型...\n",
      "词袋模型特征维度: (1080, 1000)\n",
      "前10个特征词: ['iphone', 'xr', '正品', '屏幕', '反应', '不算', '很大', '刚刚', '面容', '识别']\n",
      "\n",
      "方法2：使用TF-IDF模型...\n",
      "TF-IDF特征维度: (1080, 1000)\n",
      "前10个特征词: ['iphone', 'xr', '正品', '屏幕', '反应', '不算', '很大', '刚刚', '面容', '识别']\n",
      "\n",
      "标签编码: {0: 0, 1: 1}\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n=== 步骤4：特征工程 ===\")\n",
    "\n",
    "# 方法1：词袋模型 (CountVectorizer)\n",
    "print(\"方法1：使用词袋模型...\")\n",
    "count_vect = CountVectorizer(\n",
    "    max_features=1000,  # 最多1000个特征词\n",
    "    min_df=2,          # 至少出现在2个文档中\n",
    "    max_df=0.8         # 最多出现在80%的文档中\n",
    ")\n",
    "X_count = count_vect.fit_transform(words_list).toarray()\n",
    "\n",
    "print(f\"词袋模型特征维度: {X_count.shape}\")\n",
    "print(f\"前10个特征词: {list(count_vect.vocabulary_.keys())[:10]}\")\n",
    "\n",
    "# 方法2：TF-IDF模型\n",
    "print(\"\\n方法2：使用TF-IDF模型...\")\n",
    "tfidf_vect = TfidfVectorizer(\n",
    "    max_features=1000,\n",
    "    min_df=2,\n",
    "    max_df=0.8,\n",
    "    ngram_range=(1, 2)  # 使用1-gram和2-gram\n",
    ")\n",
    "X_tfidf = tfidf_vect.fit_transform(words_list).toarray()\n",
    "\n",
    "print(f\"TF-IDF特征维度: {X_tfidf.shape}\")\n",
    "print(f\"前10个特征词: {list(tfidf_vect.vocabulary_.keys())[:10]}\")\n",
    "\n",
    "# 编码标签\n",
    "le = LabelEncoder()\n",
    "y = le.fit_transform(df['评价'])\n",
    "print(f\"\\n标签编码: {dict(zip(le.classes_, le.transform(le.classes_)))}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d04bbf87-ec04-4f3c-af70-b926fdb55ffa",
   "metadata": {},
   "source": [
    "## 模型训练与对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "263bb5f2-2173-4204-b9b5-0488814fe6bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤5：模型训练和对比 ===\n",
      "训练集大小: (864, 1000)\n",
      "测试集大小: (216, 1000)\n",
      "\n",
      "训练神经网络模型...\n",
      "神经网络 - 测试集准确率: 0.9676\n",
      "神经网络 - 交叉验证准确率: 0.9602 (±0.0095)\n",
      "\n",
      "训练朴素贝叶斯模型...\n",
      "朴素贝叶斯 - 测试集准确率: 0.8380\n",
      "朴素贝叶斯 - 交叉验证准确率: 0.8343 (±0.0197)\n",
      "\n",
      "训练支持向量机模型...\n",
      "支持向量机 - 测试集准确率: 0.9676\n",
      "支持向量机 - 交叉验证准确率: 0.9630 (±0.0088)\n",
      "\n",
      "训练随机森林模型...\n",
      "随机森林 - 测试集准确率: 0.9861\n",
      "随机森林 - 交叉验证准确率: 0.9676 (±0.0077)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKEAAAHqCAYAAADcYF0vAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAwyNJREFUeJzs3Xt8zvX/x/HntWsnY7PNYXMYFl/klNNYyqlIjlG+SiVESSqiKSVM2kgIiULkUIpSIvKtnFPOYk5h5szETrZd267r8/tDrl9XO9hwuaYe99vtun19Pp/3+/N5fTbdfL7P6/15v02GYRgCAAAAAAAAnMjN1QUAAAAAAADgn48QCgAAAAAAAE5HCAUAAAAAAACnI4QCAAAAAACA0xFCAQAAAAAAwOkIoQAAAAAAAOB0hFAAAAAAAABwOkIoAAAAAAAAOB0hFAAAAAAAAJyOEArADenVq5e+++47h32HDx9WdHS0JOn06dN69913lZWVla3Npk2b9Msvv2T7rFu3ThaLxaH9oEGDNGXKlGzX//nnn7Vp06Yca0tOTta2bduyXfvvYmNj9dZbb+n8+fMO+6dPn65PP/00z775FR8fr+rVq2vVqlX57vPrr79qxowZN+X6AADg1nD1s9FViYmJ9j9fuHBB//3vfwv0HHJVenq6xowZo127duW7z+HDh7V06dJcj2/btk2XLl0qcC1/99FHH6levXoF6jNnzhytX7/+hq8N4PoQQgG4IT/++KNOnTolSUpLS5PNZtPp06c1ffp0SVfCl4iICLm5uSkjI8P+APXtt9/qtddeU8eOHfXkk09q+PDhevLJJ9W2bVsNHz5ciYmJat++vV599VVJ0pEjR3T27Nls1586daomT55s37ZarUpPT5ck7dixQ2FhYUpKSsrzHiIjI/Xhhx8qLS3NYf+GDRvsD1wpKSl65ZVXsj1U5lexYsV08OBBZWRkZDtWpEgRffDBB9n2//DDDxo1atR1XQ8AALiGq56N4uPjtW7dOk2dOlWdOnVSUFCQ/Yu6d999V8uXL1flypULfD8eHh5avny5evToIavVmu+fQb9+/Rz2Xb582f7nRo0aac2aNQWu5e+sVqvi4uKy7f/8889lMpmUmpqa7VhUVNR1P88BuHHuri4AwO3Ny8tLHh4ekqQnnnhCP/zwgwzD0OXLl+Xv7y+bzSZJCgwMVGZmpsaMGaOXX37Z/mnfvr1atGihiIgIjRkzRj/88IPWrl1rP7e3t7ckydPTU56entmu7+np6fBAtHv3bt199906fvy4ihQpIkn2c+Tk+++/1+eff67169fL3d1d9913n+bOnasKFSrI09NTKSkpevfddzVx4kSVKFFCjRo1svc9d+6cPvzwQ3l7e8vN7f8z/XLlyql79+4O17lay1/bXeXt7Z1jjR4eHvLy8sq1dgAAUPi46tno5Zdf1urVq2W1WnXPPfdoyZIlKl++vGJiYjRp0iQVLVpUd999tyTp0qVL6ty5s5YsWSKTyWQ/R2ZmpkNYdNXo0aO1YMECnT59Wr6+vg7H3N3dVaxYMYd9OT23lS9fXh9//LG6dOmS67OPJK1atUo7duyQh4eHQ21t2rRR7dq1HdoWKVIk12erv/7vX/F8BbgWI6EAXJd9+/bpwIEDyszM1JkzZ7R3714tXLhQSUlJ2rJli/r27auEhATt3r1b9913nxISEnT58mW9/PLLDufJzMzMMVySrgQ2Vx8+/voQIl35ZtFqtcrDw0MZGRkaN26cDMPQb7/9pnLlyikoKMj+UHL1fzMyMhyGvsfGxuqpp57SzJkzFRYWpjJlyqh48eJ65JFH7KOiPvnkE+3du1eff/659uzZo27dutn7Z2Rk6NChQzpw4ID9M3v2bC1fvlypqak5fltoGIYyMjKUmZlp32c2m3N8gPL09LQ/xF4VExOT7WcIAABcz9XPRvPnz9f58+fVsWNHNWnSRB06dFCpUqX0+OOP68knn9SFCxd04cIFLViwQP7+/poxY0a2c/zvf/9TQEBAtk+bNm00f/58VahQIdux1q1b2/tbrValpaXJw8ND7u7u+uijj3TixAkdO3ZMCQkJatCggf0+rj77ZGVlObxqeOHCBR08eNDh+erVV1/VyZMnlZ6eLsMwsv1cbDabw6gns9lsv87f5fR8NWnSJEZHAbcII6EAXJdBgwbJarXq5MmTmjdvnr799lvNnTtXPXr00MGDByVJX3zxhb29v7+/GjRooB9//FG//PKLli9fLi8vLx05ckQ//fST0tLStGHDBh0/flyRkZH2h5TcTJ8+Xd99950qVaokT09PTZw4UfXq1dPOnTsVGxvr8FB1dRSSJH322Wd67LHHJElPPfWUUlJSNHXqVEVFRSk5OVmXL19WcnKynnnmGbm7u+vFF1/U2LFj7f0feeQRDRs2TA0bNlRISIgWLFjgUFfr1q1Vp04dlS1b1mEuhqs6deok6crDzqBBg/L5074SXn388ccaNGiQvL299fTTT2f7NhAAALiOK5+NbDab1q9fLy8vL/3xxx86efKkNm7cqJ9//lmStHHjRnswc1Xp0qVVo0YNxcTE2PddHSGUnJycbXRTTl555RVt2bLFvn11RPpHH30k6cqopmPHjiksLEySVLFiRXvbtm3b2v/cr18/+zyYTz75pJ588kn7sVOnTmn27NkOo9z/7uq9Xbp0Sf7+/tes+6o//vhDL730kj799FO1bdtWbdu2zRbMAbi5CKEAXJfVq1crLi5OlSpV0quvvqpevXpJujI6aO7cuercubND++XLl+udd96RJF28eFG7d++Wl5eXTp48qbJly2rXrl06c+aMUlJStGvXLpUpU0ZWq9U+ZP3vjh49qtDQUBmGIXd3d3Xr1k3z58/Xjh07NGHCBD3++OPavXu3HnzwQR07dkyenp7KyMhQYGCg/Rz9+/fXhQsXVKNGDYWEhKhMmTLy8/PTggULFBoaqtmzZ2v//v3KyMiQp6en9u7dq6+++krPPfec/RxRUVF65JFHVK1aNUlXHr5ef/11bdu2Tb6+vg7DvQMCAvTZZ5+pZcuW8vHxcbifM2fO6MCBA7JarcrIyFBAQID92Lp16/T666/rt99+06BBgxQRESE/P7+C/9IAAIDTuPLZKCMjQy1btnTYN23aNE2dOlXr1q2Tu7u7ihQp4hBEjRo1SsuWLXPoU7p0afXr10/nz5/XkSNH5OnpmWMok5mZqfT0dFWtWlUlS5a07z969KgqVKhgv84TTzyhwYMHKyEhQY888ojef/99SVLlypU1a9YstWzZUllZWQ7PS/Hx8Ro/fryio6NlNpu1a9cuVahQQd27d9cDDzwgPz8/+/k//fRTvfnmmzp06JDS09OzPR8dOHDAXm9GRob9eS09PV2TJ0/WW2+9peDgYC1dujTb7weAcxBCAbhuX331laQrq7iVL19erVq1kpubm1544QW99tprDm0vX75snwyzXbt2ateunWJjY/Xll19q1qxZqlatmn3eg6urqSxdutQ+yfjf7d+/X+3atdP+/fslSQMHDtSWLVu0cOFCdevWTcHBwTp58qQkKSgoKMc5AR577DGHScttNpsSEhL00EMPydfXV/v379czzzyjIkWKyGQyyWazqXbt2rrvvvvs7bdv365Zs2Zp8+bNOn36tBITE9WoUSN5enrqt99+y/atZbFixRQUFJStlrfeekvjxo1TVlaWMjIy1KdPH1WrVk1Hjx5Vly5d1L9/fy1btkwlSpS49i8GAAC4hKuejby8vPTrr78qPj5eHTp00MCBA/XUU0+pbNmy8vHxUUZGRo6vpv19X+3atTVjxgy9/fbbGj16tLy8vOTm5iabzabk5GT5+vrKzc1NVqtVmZmZWrhwoZ599ll7//3796t69er27Q4dOsjLy0tPP/203nvvPQUHB0u68iphQECAffuvLl26pE8++UQpKSn64IMPtHr1at17773y8/NTfHy8bDab/XnIx8dHJpMp1+ej8PBwSVdCuoyMDPtE7VFRUapbt66mTZum//73vzn+bAA4ByEUgOtiGIbmzJkjd3d3nT9/Xj169FBMTIxsNpvef//9PL/tu2r06NGqVq2a/Vupqw80V73//vv2YddWq9X+gGAYhrZv366hQ4faQ6gqVaroyy+/VMuWLVW+fPl83cPp06cVEhKSbX+tWrW0Z88eVa5cWQsXLlTVqlUlXXlgql69usM8A5999pk6dOig9u3bq2XLlrrnnntUtGhRzZgxQ6NHj9bhw4ezjXrKyQcffGD/xvSq9957T2XLltXBgwdVtGjRfN0TAABwDVc+G5lMJjVq1EgTJ06UdGVEU+nSpRUcHKxVq1Y5vPr2V/Xr189x/xtvvKE33njDvr13717Vrl1bv/32mypVqpTrz2Dr1q2qVauWfdvLy0t+fn4yDEMPPfRQrv3+qmrVqlq9erWaNWumkJAQffvtt/bVgp944gk1btzYYWXkvCQkJOS4f+DAgZo0aVK+zgHg5iLyBXBdli1bJqvVqooVK6pjx46qVauWvv76a1ksFj3xxBPy9/d3+Dz22GP2b+4SExM1YMAAzZ07V1FRUfZzWiwWZWRk2LcrV64sT09PRUREaOPGjfZX1AzD0KJFi+wrvFz16quv6pNPPtHu3bu1f/9++5K9hw4d0r59+7Rjxw6H818d+n3ixAkZhiHDMDRz5kz7qKkPP/xQP//8sxo2bKiGDRvKZrPp4sWLDtf09PTU4sWLlZaWpnfffdc+cXnPnj0lSVOnTr2hn7O3tzcBFAAAtwFXPhtdbTtx4kT5+vrq66+/1r333qs//vhDzZs3V3Jysmw2m/15xzAMjRw5MtdpD86ePatly5Y5LOiSH6NGjVLv3r0d9jVr1kxHjx7VgQMHtH//fh04cECGYejkyZPav3+/du3apQsXLjj0ueuuu/TFF19oxIgROn36tH1OzWHDhmnGjBk6fvx4ger6O0aWA65DCAWgwP744w+9+OKLeuaZZ+z7vvjiCz399NPat2+fLl++rISEBJUrV06zZs1SQkKCUlJS7BNXZmVl6X//+59GjRqlhx9+2H6Onj17qkmTJvr444/t+0qWLKl169bpvvvu0xNPPCHpygikBx98MMd5kWJiYhQeHq7w8HD7yKJmzZopPDxcjRs31pkzZ+xtr66MEhISIpPJJJPJpGeeecY+0snb21teXl5KTk7WyJEj1bRpUw0dOjTbNYsXL27/WVx9va9IkSJ66aWXNHHiRPtKewAA4J/J1c9GkjRhwgR5enqqY8eO6tSpk+69916NGzdOL774ov01uqvPOyaTSZGRkblOe/DTTz/poYce0tatWx32HzlyxL5iXUxMjMOk5tKVkVVXR5D/lYeHh+6++277M1pqaqoGDRpkfz5bsWJFtj5t2rRRrVq15O7urkuXLkmSHnroIYWGhmr8+PG5/i4AFG68jgegwOLj4+Xp6am+ffvaJ5gMCAhwWJJXujLJ5l9XKLm6BG+JEiW0detWpaam2icNd3NzU/HixZWQkKClS5eqXbt29n5Lly6Vm5ubw6TiuWnTpo099Nm2bZvCwsJ09uzZHOeEuiomJkZly5aVdGV544ULF9qPLV++XHPmzJFhGHrrrbdyXNEuMTFRY8eO1UMPPaQRI0aoffv2qlmzpnr27KmYmBilpKTkuppLbs6ePVug9gAAwHVc/Wx05swZvfXWW5ozZ45WrVolSZo5c6ZsNpsyMzM1ZMgQJScna/fu3fL29lbHjh0lXRktnpP58+crLCws26jzLl262F8BvDrqa+/evdf8+Xh7ezuM6CpWrJiWLFmiBx98MNc+n3/+uY4ePaqwsDD17NlTa9eulZubmwYPHuzwimJ+paSkFLgPgJuPEApAgVWvXl2bN2/OtnRvx44dtXXrVnl4eNhXOnnhhRd09uxZeXh4yMvLS48++qgmTJig4sWLq3379tq0aZNMJpP9gebqsPCr8zoZhiGbzaY2bdrYH6pupatL97700ku5hmDPPfecKlWqpK+++kr//e9/1atXL/3yyy8qU6aM5s+fX6Dr/frrr3r11VdVunRpNWnSJMc2Z86cUZkyZQp8LwAAwDlc/WxUpkwZvf/++3rsscfs+4oUKaK+ffsqKytL4eHhmjdvnt577z099NBDeuSRR5SRkaE2bdrou+++cwib9uzZo9WrV+u+++5TZmamfeS4pGvOCXWznDp1SgMGDFB0dLQeeugh3XnnnZo6daoGDhzoMBF6fmRmZmrmzJkaPXq0w4iyv0pLS5PFYnEICAE4B6/jAbgupUqVyrbvhx9+UGJiok6dOqU2bdpo0qRJ+uSTT1S3bl3t3btXJ0+e1IQJE+ztv//+e1ksFtlsNmVlZSkrK0vPP/+8unXrZt+2Wq2yWCz2VWGcoWbNmgoICFBAQIBeeuklh2O9evXSqFGj7AGUYRgOx0eMGKHvv/9en332mdzc3PTee+9p3759DqOp8mIYhiwWi3bu3Kn27dsrPDxcHh4eevnll3Pt06BBg2x1AgAA13L1s1GfPn2yXX/NmjVq27atfYqBRo0aaezYsfr9998VExOjwYMHa+DAgfbnG8Mw1K9fP4WEhCg9PV0tW7bU4cOHb/JPKm+XLl1S+/bt1bRpUz3//PMqV66cRo0apREjRuR7NNPV1ww/+ugjVa1aVUOHDlWPHj3UqFGjHNuvW7dO5cqV04YNG27afQDIGSOhANyQq5NcSlJcXJxWrFihGTNm6LnnntPjjz8uSerfv7/q1aunIUOG6Mknn5S7u7tOnDghLy8vmUwmh/MlJCQoOTlZBw4cyHadtLQ0lS9fXkFBQfb9VyfXvNo3NTVV3t7ecnNzsz+oJCYmKj09XRkZGbJYLNlWxDtx4oT928UZM2Zo7ty5kq7MPXX27FkZhiGTyaTk5GQ1bNhQr776qp5++mm99NJLmjVrllavXq3Q0FBJsq/i0rRpU4drHDlyRNL/T4Z+1bZt25SSkqIpU6aodevW2rRpk30E1G+//abjx49r/fr1Kl26tCRp06ZNOnPmjGrXrp2v3w8AALi1XP1sdHXk1J49e3T06FE1b95c33//veLi4hQTE6MmTZpo4cKFmjRpkg4cOKCVK1fq3LlzCgoK0vPPP69ff/1Va9asUVhYmAYNGqTatWvbR0pt3rxZiYmJ8vLykmEYSktL08WLF1WuXDndeeed9hr++nyWnp6uCxcuqEiRIvZ5NyXZ58nKyspSWlqagoKCFB8fr1atWsnf39/hC70XX3xRdevWdRhpZrPZFBsbm+3ZSroSvknSyy+/rAEDBigiIsIeEhYpUkTr1q1Tly5dZDabZbPZ9MEHH8gwDNWpUydfv2MAN8AAgBtQtmxZ44MPPjAOHjxo+Pn5Ge3btzf27t2brd2mTZuMOnXqGB07djQWLVpkFClSxPDz8zOKFy+er4+fn5/h6elpzJgxw+G8TzzxhPHYY48ZhmEYI0eONCTl+SlRooS974ULFwxJxokTJ+z9y5Yta9x///2GYRjGJ598Ynh5eRlms9kwm82Gm5ubERoaapw8edIwDMPYvHmz8cMPP+T587FarcYdd9xhSDLKlCljnD9/3uG4zWYznnzySWP16tXZ+p44ccK48847Hep3c3Mz2rVrZ6Snp1/rVwMAAFzA1c9G//3vf42RI0camZmZxrZt2wzDMIy9e/caFSpUMNzd3Q03NzfDz8/PGDdunEO/r776ynB3dzemT5/usH/Pnj1GRESEcc899xjBwcGGu7t7tuerAwcOOPSZOXOmERwcbBiGYaxZs+aaz2eSjD179hg2m814//33jYSEhDx/xj/99JPh5uZmSDL69u2b7XhMTIzx2GOPGadPn852bM6cOYafn5/DtYsVK5bt5wjAOUyG8bd3SwDgOiUnJ8vX1zfX48af35j5+PjctGs++uijysrK0pdffmkfvu7l5WWfR+GvMjIylJmZqaJFi0q6Mt9A+fLl7SOhpk6dqokTJ2rq1Knq0KHDTavxf//7n0wmk+6++277tQEAwD+fK56NHnzwQdWtW1djx44tcN+4uDhVrFjxmu2uPlNZrVZJyrZi8fTp0zV8+HD98ccfslqtSk9Pl5eXl32C9r+6erxIkSI5Pr/lxDAMzZ49W40bN1atWrWyjR4DUHgRQgHAn6xWq8MwcQAAAADAzUMIBQAAAAAAAKdz6ep4Fy5cUGhoqI4dO5av9uvWrdOdd96pkiVLauLEic4tDgAAAAAAADeNy0KoCxcuqEOHDvkOoOLj49WpUyd1795dmzdv1sKFC+2rHgAAAAAAAKBwc1kI9dhjj9mXKM2PhQsXqmzZsnrzzTf1n//8RyNGjNDs2bOdWCEAAAAAAABuFpfNCRUbG6vQ0FCZTCbFxsaqUqVKebbv3bu3ihQpog8++ECSdObMGd13333av39/ju0tFossFot922az6eLFiypRogSrJwAAAElXVlhKTk5W2bJl870q07+JzWbT6dOn5evry/MTAACQdGPPT9nXyLxFQkNDC9Q+KSlJNWrUsG/7+fnp9OnTubaPjo5WZGTkddcHAAD+PU6cOKHy5cu7uoxC5/Tp0woJCXF1GQAAoBC6nucnl4VQBeXu7i4vLy/7tre3t1JTU3NtP2zYMA0ePNi+nZiYqAoVKujEiRPy8/Nzaq0AAOD2kJSUpJCQEPn6+rq6lELp6s+F5ycAAHDVjTw/3TYhVGBgoOLj4+3bycnJ8vT0zLW9l5eXQ2h1lZ+fHw9RAADAAa+a5ezqz4XnJwAA8HfX8/x020x+EBYWps2bN9u3d+7cqXLlyrmwIgAAAAAAAORXoQuhkpKSlJmZmW1/p06dtGnTJv3www/KzMzUO++8ozZt2rigQgAAAOfZu3evwsLCFBAQoIiICF1rDZnMzExFRESoQoUKKlOmjEaMGKGsrCxJVyYO7d+/vwIDA+Xv769evXopLS3tVtwGAABANoUuhKpTp45WrFiRbX/JkiU1adIktWvXTkFBQTp48KCGDx/uggoBAACcw2KxqGPHjmrQoIG2bdumffv2ae7cuXn2iYyM1MqVK7Vq1Sp99913WrhwoX1xlvnz5+vgwYPauXOnNmzYoJiYGEVHR9+COwEAAMjO5XNC/f3bvWPHjuXa9rnnnlObNm104MABNW3aVMWKFbvp9Vit1hxHYgHX4uHhIbPZ7OoyANxiY3decHUJBfZavZKuLgG5WLlypRITEzVx4kT5+PgoKipKAwYMUO/evXPtM2/ePE2aNMm+ivCQIUM0Y8YMvfXWW9qyZYu6du2qihUrSpI6d+6smJiYW3IvAAAAf+fyEKqgQkNDFRoaetPPaxiGzp49q4SEhJt+bvx7+Pv7Kzg4mAluAQDXZffu3QoPD5ePj4+kKyPE9+3bl2efCxcuqEKFCvZts9ls/1KkZs2amj9/vh555BGlp6dr0aJFDqsH/53FYpHFYrFvJyUl3cjtAAAAOLjtQihnuRpAlS5dWj4+PoQIKBDDMJSamqrz589LksqUKePiigAAt6OkpCSHL9tMJpPMZrMuXbqkgICAHPvUr19f33zzjcLCwmS1WjV//ny1bt1aktS3b19Nnz5dwcHBkqSOHTuqZ8+euV4/Ojra/iofAADAzUYIpSuv4F0NoEqUKOHqcnCbKlKkiCTp/PnzKl26NK/mAQAKzN3dXV5eXg77vL29lZqammsINW3aNHXo0EFbtmzRkSNHdPz4cc2fP1+SNHnyZPn7+ysuLk4mk0n9+vVTRESEJkyYkOO5hg0b5jBSKikpSSEhITfp7gAAwL9doZuY3BWuzgF1deg7cL2u/h1iXjEAwPUIDAxUfHy8w77k5GR5enrm2ueuu+7SsWPHNGnSJBUvXly9e/e2j6ZauHChfeW8kJAQRUdHa/bs2bmey8vLS35+fg4fAACAm4UQ6i9ux1fwLl++nK92Fy5c0Pbt26/ZzmazXbPNzJkztWPHDknSjh07NGrUqHzVcNWZM2fsc0zs3LmzQH0lafbs2Tp69Gi+26ekpBSo/Y24Hf8OAQAKj7CwMG3evNm+HRsbK4vFosDAwDz7mc1mpaam6uDBgw7/LttsNvur4tKV6QesVutNrxsAACA/eB3vNvfwww+rfPnymjZtmmbPnq1Lly7Zj1WoUEFPPfWUJGnTpk0aP368Nm7cqN9++01lypRRqVKlsp3vueeeU8WKFVWuXDn98ccfGjJkiMPxP/74Q6+99ppWrVolSSpfvrw+++wzderUSfXr1892vsuXL+v48eO688477fvGjx+vHTt2aPXq1erVq5fat2+vqKgoh35JSUm6ePGi3N2v/BXNyspS2bJltXPnTg0aNEh79uzJ989o/vz5mjZtmvbu3ZvvPgAAuEKzZs2UlJSkOXPmqHfv3oqKilKrVq1kNpuVkJAgX1/fXF/3HjFihIYMGaKyZcva9zVt2lRjx46V2WxWRkaGxo0bp06dOt2q2wEAAHBACHWTnEl1zetX42fMVr+nHtecz5doyrRp6vbEUyoeEKAjhw7pf2vWqUq9MP2ycaOCy5SRzc2sM6mZmjlvgdb9+IN+2bQx2yuInp6eyszMVPPmzRUWFqZq1aqpQ4cO9uOvvPKKLl++7LBUtJubmz3sMgxDFotFn332mcLCwrRixQq98MILWrdune68807ZbDZ99dVXGj9+vDw9PbVixQpNnTpVhmHY+7u5uemnn35SZGSkjh49qsDAQBUvXlxz585Vnz59VL58eXXt2lWnT59WhQoV9PPPP8vN7cqgvg0bNqhr164qWbKkfY6my5cvKy0tTQ0bNrTXnJiYKEn6/fffnfBbwb/N2J0XXF1Cgb1Wr6SrS4ALJd6GE08XHznS1SXcEu7u7po1a5a6d++uiIgIubm5ae3atZKkgIAA7dy5U3Xr1s3Wb926ddq1a5cWL17ssH/MmDFKSkrS0KFDlZycrDZt2mjy5Mm34E4AAACyI4TKw63+P5Y9qxUvcJ9SQUFa/N1qmc1mvT9hvDp0eVjbftmspi1a6kDMXp06cUJLP/9M/Qf9/ySjwyLH6NjRI1q5cqXat28vT09Pe4jj7e0tSQoNDdWyZctUq1Yte78vv/xSc+fO1fz58/Xkk09KkmbNmqXly5fr66+/lnQlRLoaJElSt27dFBMTo9atW2vTpk3atWuX4uLi9MorrygiIkKJiYny8PDQwoULdfnyZU2ePFlPPfWUOnfurM6dO6tq1apatmyZqlSpoocfflh33XWX5s+fr6ysLNWrV08zZsywX0u68o3vtm3b7JOonjt3Tg0aNNCKFStUs2ZN+8iq3377TXfccUeBf94AADhbp06ddOTIEW3fvl3h4eH2RVOufmGTk+bNm+vMmTPZ9vv7+2vevHlOqxUAAKAgCKFuY5cuXtTEqDEaNnqMfUSTm5ubXujTS7M/+8K+rb/NU2QymTRj3qcKLuKuoKAgFSlSxD60PykpSVlZWZo7d65sNpseeughTZ06VbGxsXrmmWdUrVo19ezZU7169ZL0/6HT1XDHarVq6dKl6ty5s/16o0aN0uXLl+Xn56e3335bknTkyBG5u7urV69eqlWrll555ZVs93fy5El5eXmpevXqSktL04MPPqgVK1aoUaNGSklJUVxcnPr27StJGj58uDp37iyLxaL7779fXbp00dixY/X666+rR48eqlKliurWraspU6aoXLlyevDBBzV8+HA9//zzN+8XAtxGGAkDFG7BwcFq3769q8sAAAC4qQihbmMeHh6Kiz2q/7Ztrc+WfSdJcjObZTabVcw359VsVi77Wl99/pkSLyVowYTxOvvbbw7HZy5YoF937NCsiRPt+7JOn1bsjh3q9+STOnX2rIYNGKAnHnlEkjT700/13Q8/6MuPP5YkXU5NlclkUtbp0w7nHTt4sGbPnq0jf77+lnX6tOTuLltqqmxJSco4eVLpFot8/nyFTpJmvveerBaLnu3RQ15eXpo0erSmTp2qrVu3asGCBTp58qTGjBmjXr16KSEhQdKVVX02bNigUaNGafz48Vq8eLGeeeYZde7cWW3atFGLFi30xBNPaOzYsfZXCAEAAAAAgPOxOt5trJivrz7+fIke7PiQihYrJunKyCQPD49cJy1t26mzZi78XMdij8pqs2nDL7/Ir3JllaheXb6VK8vNzU0n/xYgSVKzu+/WW6+9JkkaMW6cGrRurQatW+vtSZO09uef7dt3t2un6XPn5nhtq9WqkRERkqTq99yjKo0b66sVKxQ9ZYqqNG6sqnffbW979vx5TZ45U/Vq11ZYvXr69Msv8/xZXB2JJUlBQUHq06ePOnXqpAULFmj79u26//771bRpUx08eFD9+vVTlSpV8jwfAAAAAAC4uRgJdZtzd3dXl26Pymq1yma16o/4CwoIvDJ3xLWWYPb08NA9jRrpjwMH5Fu5spIOH9bxU6c0avz4XPtcvnxZ1f/zH1WrXFmStO/QIcUeP67mfwZIhqSjcXFKuXxZxYoWtffr2qePPhg3Tp4eHhr4xhs6sGmT3N3d9fSgQapVvboGP/ecva1hGOoxYIAkqVH9+urRtaveHDtWkpSZmalmzZrpjz/+UGZmplatWqVjx46pVatWkqSjR49qzJgx2r59u4YPH66xY8eqSpUqKlasmCZPnqxTp05p6tSp6tOnj9q2baupU6fK9LfXFQEAAAAAuB38MWeuLuYyECQvgb16qUTvXje9nmshhPoHGPVahKrXrKX09HT9fmCfgsqUkSRZLOmy2Wyy2XIPo9zc3OwTe3t6eqpKaKiysrJ06MgRVf0zaPqrDg88oEohIfrPn5N6PzNkiMaPHKlG9epJ+nN1vIwMh9fq1m/erMOxsSpdsqQS/lyVrnHbtpKkE6dP64f16/XJ558rISlJcdu3y2QyadhLL2n1unXZrp+amqpdu3Zlex3vqqNHjyo1NVW//vqrfvzxR7Vs2VKZmZmaPXu2Pv30U7399tsqWbKktmzZos2bNxNAAQAAAABuW7aUFGWdO3dd/VyBEOo2d/LEca3532qNHj9RvZ/tr6nvvqOw8CYqWaqUPlv2nX7dtFEZGRk59o3/4w+9+8EHenfUKIf9TcLC9OOGDapaubKsVqvMZrPiTp5U28cek6enp0Pbo3FxOvD77yr658TokpSRkaEODzygd0aMkCRNmD5dff9cTe+qX1euzHUklCTd17SpNm7Z4rDPZrPp4sWLatu2rc6dOyeLxaKNGzfqwIED9pFQd999t5o3by4PDw+1b99e7du319dff63t27frzjvv1IIFC+zna926tSwWi7y8vPLxkwYAAAAAoHBxK1ZM7kFBjjsNQ1nnz0uS3EuXzrZY2dV+rkAIdZubFP22Hu3RU2XLlVfCpUv6fMEnihz3rjq3bqlPv1mhFq1aq0Wr1lqz+nuHfjabTR2efFKPtG+vuJMnZRiGeg8cqJb33KOnunXTuPff15Ndu+qxfv20ZNYsVSxfXvs2bpQkxR4/rmcGD1Z4gwZas2mTXujTR5NnzlTrZs30cr9+CgwIsF/nx/XrtW7zZs17//1r3ovVapXVanUIusZNnaqZ8+crIzNT23/7TZ6enlq/fr0+/PDDHEdC3X333bJarfLw8LDvS0xMVHx8vOrWretwvaysLD322GMaPnx4QX7kAAAAAAAUCiV6Z3+tzpaaqoP1G0iSKq9aKbe/DBpxNUKo29jGtWu05NMF2rg7RpIUOWyowu5uom5PPqXMzEz17/mk/rd5q7y8vXXu7Fn7q2cnTxzXuTOnNea112R2c1P9Vq30+MMPq03LlnqgeXMV9/PTkJEjNWTUKG3etk1eXl66eOmSPvv6a333ww+KOXBAUW+8occfflhNOnRQcKlSWvvVVxr3/vuq1by5at95p9q3bq2X+vbVzr171bt7dxX3u7Ja39V5qopUrOhwL6++9ZakK6Ow1n39tb3tqy++qP49e+q/ffvqi2++0aOPPprtFTrDMOx//u1vq/1J0tdff613331XG/8M0QAAAAAAwK1HCHUbq3VXXY0a965CKlbStl9/0fqfftSyn67Mo/R4r6d1+NAhpaWm6stFn+rNV15WxJujJEnlyodo7hdf6bHwhkpLS1P/Xr3k7e3tcO6P3n1XD/XqpScfeURubm7y9PTUD+vWqV2rVlo8a5Z9zqfMzEwlX74sb29vjXzlFQ3p319fr1ypQH9/SdIrzz8vm81mP2+6xSJJSouLc1jRTvr/kVBXVapQQUElS8rNzU3vjBih//btqx/WrpUk3XnnnQoODta3336rtWvX6tlnn83152SxWGT587oAAAAAAMA1TMZfh5H8gyUlJal48eJKTEyU35+jcq5KT09XbGysQkNDs4Ux+XUmNfNmlHlD0tPTc6w/PT1d1qwsFf3bO5+lEuLzPF9ScrJ8ixUrVJN3u5ct67CdmJgoNzc3+fr6uqgiRzfj7xJuP2N3XnB1CQXWf9k0V5dQYMVHjnR1CTni939rOOv3n9fzAfj5AABwO/rr63jVdmy/6a/j3cjzASOh/kFyCz2uNwzxKyTBTl6KFy/u6hIAAAAAAEA+EEIBAAAAAHCDPon5RPP2zStwv6dqPKWeNXs6oSKg8CGEAgAAAADgBl3OvKzzqeevqx/wb0EIBQAAAADADSrqUVSlfUo77DMMQ/FpV+biLVWkVI7z7Rb1KHpL6gMKA0IoAAAAAABuUM+aPbO9VpeamarGnzaWJC3vslw+Hjd3gmjgduPm6gIAAAAAAADwz8dIKAAAADjNrA1HNWtDbIH79W0aqr5N73BCRQAAwFUYCfUPk5qaqq8Xf66ES5du2TVtNptsNts129youJMnlZ6eLknasWNHgfoahqH3339fZ8+ezXefS5cu6eTJkwW6DgAAcJScnqWzSekF/iSnZ7m6dAAAbkuG1Wr/c+q2bQ7brkYI9Q+TlZmpIc/306J5c3Ntk3Dpki6npCgtLU3p6em5fqx/+YuamZmprKycHwa/XrlSpWrUUMzBgzke//Srr9TzxRft238/t732rCxlZGRIks5fuKDjp045HH9l1Cg999xz+uOPP9SpUyd99NFH2c5x8eJFxcXF6eTJkzp58qRiY2NlGIYWL16s6OhoeXt75/pz+buxY8eqX79++W4PAACy8/V2V7Cft8MnyM/LfjzIzyvb8WA/b/l6M2AfAICCSlq9Wkfbd7Bvn3i2nw7f30pJq1e7sKr/x7/ueUiMjMx325sxvVxqxOsF7pOSnKyixYrZV1nwK15cPZ95Tqmpjst8Wq1WXU5JkV/x4mrb9G6dPnlCWVlZ8ilSJNs5DcNQalqaVn32me5v1kyS9N5HH2nKrFny8vTU5dRUPdCihT6ZOlWSNHX2bDW/+26NnTJF86dNy3a+B1q00Jtjx2rC9Onq9eijqtCggTzc3eXu7q7LqanycHeXp6enMjMz1TQ8XMsXLNC8L77Q7IULtWbpUgWXLq2k5GT9b906rVm7ViVKlNC3336r//3vf5KujLIymUwymUxatGiRZs2apf3796tChQry8vLS119/rYEDB6p06dJq1aqVjh07ppYtW2rx4sX2GhcuXKiIiAiVLFlSnp6ekqSkpCRZrVY1bNjQ/nO5dOmSKlasqDVr1hT4dwUAwL9R36Z3ZHutLjUjSzVGfC9JWvNKC/l48kgKAMCNSlq9WqcGDpIMw2F/1rlzV/ZPfk9+Dzzgktqu4l/829wDTRrp4h8XZHbP/qucPf3/A6H0tDT5BwRq+6Gj2rz3gGJ+262H7mum07/9Jp8iRZSWlqYifwZSS7/7Tk8PGqSm4eH2/hEDBuj0uXN669VXNX/xYp06c0aStHjZMhmGoSWzZ6vd449r7JQpeu2llxzqKBkYqAUffCB3d3eVCAzU5dj/nxfioaee0sPt26vno4869Hnl+ecVc/CgHuzeXWu/+krzFi9WWnq6/vvf/0q6MuKpaNGimjRpktLS0vT111+rRYsWev755/XMM88oKChIW7dulZubm+6//3716tVL0dHRunjxoho0aKApU6Y4XO+JJ55Qs2bNFBISIknas2eP2rVrp19++UVBQUFy//Pnu2XLFtWvX79gvyQAAAAAAJzIsFp1Lio6WwB15aAhmUw6FxUt3/vvl8lsvvUF/onX8W5zP+/ZrwOn47Vqw2bdVa+BVq7/WTHHzyjm+Bl99s0K1ax9l1au/1lH4hP0675D9n4169ylMkFBWvXTT1q8bJnu6djR/rrdih9+UIfWre0jgq6a89lnKurjo/MXLiiodGkdPHxYr40Zo4/efVdubm76YuZM/bRxozr16KFf/zZn090NGyqsbt0C3duH48er5T33yM3NTe99+KHKlC6tY8eO6dixY6pfv76mTp2qM2fOKCEhQS1atLD3+/XXX9WkSRP5+fkpMzNTTz/9tH788Uc1bNhQDRs21MWLF9WxY0c1bNhQv/76qyQpPj5eDRo00Pvvvy+bzaYhQ4Zo+PDhMplMql69umJiYvTzzz+rTZs2WrlyZYHuAwAAAAAAZ0rdtl1Zec2BbBjKOntWqdu237qickAI9Q8QF3tU3do/KJPJpBIlS9n3h1auolKlS6vNPY317VdL7KN5ruraoYMWLFmiTm3aKC0tTdPmzFHK5cta+t136v3YY9mu4+3lJZPJpHPx8Sru66uuffqoUb16avTggypRvboqNWyoS4mJqlOjht778ENJ0oDXXlPfwYPVvV8/xR4/Lkm6eOmS4nKY8NswDIcJzD09PTVp9Gi9+8EHupyamuO9W61WpaWlOeybPXu24uPj9dxzz2nq1Knq16+fzpw5o23btqlbt26aMGGCtm3bpmLFitn7lipVShs3btTRo0c1ePBgxcTE6Pfff9fDDz+sAQMGqEaNGho+fLi++OILdezYMT+/FgAAAAAAboms+Pib2s5ZeB3vNvfdN0sV8eLzateps+5/sK19jihJsqSny7tIEQ0YHKEX+/RSuZAKqh/WyN736ccfV81mzXTyzBlFDx+uzMxMffLFFyobFKSW997rcB2r1So3tyuZ5fkLF3RHxYr6ddUq+RQpoqysLB2Ni1PVypV18dIleXh4qFjRopKkaWPHSpKqNG6slMtX5qn66rvv9P2aNVo8a5Yk6cXXX9eQUaOUmpam9956S8/26JHtPocPHqyIyEhVqlRJknT27FnFxMRo8ODB9lfvpCuv0S1YsEAvvPCCypQpo88//1wjRozI9ef312CuatWq6tatm7y8vNSiRQu99dZbevnll5WRkaFz585p4MCBKlu2bP5/OQAAAAAA3ALupUpdu1EB2jkLI6Fuc3dU+Y8GDxuu8e9P1ycffagZU96zH5s28V0dOrBf/QcN1s97DzgEUJJ0R8WKanvffRo9YYI6t22rB++7T9GTJ2vkK6/YJzq/Ki09XRcuXlTJO+/Uih9+UMcePRR7/Ljubt9eKZcvq0WXLleuOWeOho4ena2/JHl4eEi6Evx4/vlnSZoaFaUL+/cr9dgxhwAqNS1NHXv00JuDB6tp48YKLlXK/jpeeHi4pk+fruPHj9sDqLS0ND322GMqWrSo7r//fj388MP2a8bHx6thw4b65JNPNGbMGDVs2FDbt///MMTffvtNXbp00auvvqqDBw8qIiJCjRs31sWLFzVlyhR17dpVNptNrVu3VnR09PX8qgAAAAAAcAqfhg3kHhws5fD/xSVJJpPcg4Pl07DBrS3sbwihbnPVa9ZSn/4DJEmvjozUvFkfKvbIYf368yYtmj9X7304S2azWWXLlc+xf+TQofpi2TKt+/lnRYwerSqhoXqkQ4ds7YoVLaqMkyd1Yf9+pcXFKaB4cZUuWVJuJpOSUlJUxNtblxIStG3XLnXNof9f5fKfRDZLvv1WbiaTPUg6/8cfqlu3rurWratt27bplVdeUY0aNdS4cWNJUpEiRTRu3Dh16tTJ4TwZGRkqVqyYtm3bpp49e2r48OHatm2bGjT4///4tm7dal/1Li0tTY8++qiSkpK0evVqffbZZypZsqTq1q2rTZs2qUmTJvm8AwAAAAAAnM9kNivo9WF/bvz94JUdQa8Pc+mk5BKv4/2j1G3QUE8/97yeefxRXYiP1/j3p6vyf6rm2af2nXdq6IAB6tq3rwzD0Pb//S/HUUwHDh/WsePHdfDIEVUsX16XU1Pl7+enpuHh2vDLL6pRrZoOHT2qvQcOqElYWI7XWr12rS5eupSve7HZbHrvo480euhQ+77SJUpo165dkqQWLVrohRdeUNeuXR36dejQQUuWLHHYd+HCBSUmJqpFixY6evSoihQpogULFtjPZRiGHnvsMfXs2VNubm7q3bu3JOm9997Ttm3bdOedd+rrr7+2ty1TpowyMjKyTdwOAAAAAICr+D3wgDT5PZ0b87ayzp+373cPClLQ68OuHHcxQqh/EMMwVDooWPtj9qpEyVIqWz7kmn3+uHhRBw8fVkZGhor6+Gjnnj2qWD77qKnoyZO18ddf1eKee9Swbl3ZDEMeHh6qV7u2Dvz+u94dOVJ/XLqkKqGhKlKkSI7XenPsWEUOHaqA4sWvWdecRYuUlJystvfff822VqtVNpvNPmJKkgYMGCAvLy8VK1ZMmzZtUrVq1bR27Vq99tprqlKlivr27WtfUS8hIUFhYWHy8vJyOEd8fLzS0tJU9y+r+hmGoaysLEVERKhXr17XrA0AAADAv5fVZrX/efu57WpStonMbq4diYJ/Nr8HHlDRu+/WoT+n4wn56EMVvecel4+AuooQ6h/g1MkT+mHld/rkoxkq4uOjH37Zps0bN6h7p3aqXbee2j3URY3ubqI7/lNVPj4+kqQ/LlzQrGmTNemjj3TfPffo6JYtWvTNN3p60CBFTpignt26qd3996tq5cqSrkwwfnWy8dS0NPkUKaKMjAw93K6dPbiZMH26WjVrJqvVKpPJZJ/IPCsrS39cuqR7GzdWvx499PmyZTneh2EYysjIkJeXl3bHxGhA794y//kfitVm06mzZx1Gaa1bt87+5yeeeEILFiy40tZq1bRp09SgQQONGjVKixYtUvfu3XO8niQFBATo8OHD2Y5fHQl19bwAAAAAkF8/xP2g6C3/P5/s8z8+ryCfIL3W6DW1qtjKhZXhn+6vgZNPw4aFJoCSCKHyVHzkyHy3PZOa6cRKcpaWlqbWdzdU7OHDCr+3qV4ZPkJtO3WWyWTSnbVq6+FHu2v+rI80f9ZHGj5kkO574EE9N/BlzZw2Ret++J/q1qypBdOm6YE/RwQN6N1bXTt00NRZszR+2jRFREYqrF49rf3qK3sA1X/oUG3bvVtV77hDU2bN0tTZs7O9bjp55kzNmzpV9zVtKkn6euVK+fv56YNx41SyRg15eXrKzc1NJe+8U5K0aetWDRk1SjabTWnp6UqLi9OUt9+WzWaznzPdYlG54GCdPHMm28/BarXKav3/bxhq1qypoKAglSlTRr1799agQYPsQVKjRo1UunRpffzxx/r999/zXO3OYrHIYrEU+PcCAAAA4N/th7gfNHjtYBkyHPafTz2vwWsHa2KLiQRR+FcyGVeHg/zDJSUlqXjx4kpMTJSfn5/DsfT0dMXGxio0NFTe3t7XdX5XhFCStO3XXxRSoaKCypTJs925M2dkyJBhGJo28V117f6EWleumGv7rKws/bRxo3x8fHRvo/9fVe/rlSuVcvmyHrzvPpUMDMxXjTabTYdjY+2jqm6Eex6hUUFcuHBBxYoVu+7fd25uxt8l3H7G7rzg6hIKrP+yaa4uocAK8sXArcTv/9Zw1u8/r+cDOO/nk5qRpRojvpck7RvdRj6efC8K4J/DarOqzZdtdC71XI7HTTIpyCdIqx5Zxat5cApbaqoO1r+yEFe1Hdvl9ucbUTfLjTwf8C/+ba5h4/B8tftrSDXm3UlX/pAQn2t7d3d3+wipv+rctm2B6pMkNze3mxJA3UwlS5Z0dQkAAAAA/oF2nN+RawAlSYYMnU09qx3ndygsOOdFnYB/KjdXFwAAAAAAwD9FfGruX/ZfTzvgn4QQCgAAAACAm6SUT6mb2g74JyGE+ot/yfRYcCL+DgEAcG1W2///e7kl9qLDNgDc7uqXrq8gnyCZsi3hdIVJJgX7BKt+6fq3uDLA9QihJHl4eEiSUlNTXVwJbndX/w5d/TsFAEBB7d27V2FhYQoICFBERMQ1v+DIzMxURESEKlSooDJlymjEiBHKyspyaGOz2dSkSRNNmDDBmaXny6q9Z9Rq4jr7dq85W3XvuJ+0am/2FXAB4HZkdjPrtUav5XjsajD1aqNXmZQc/0pMTC7JbDbL399f58+flyT5+PjIZMo5tc5NpsU1q+PdiPS/PaDeDtzT011dQo4Mw1BqaqrOnz8vf39/mc38gwIAKDiLxaKOHTuqTZs2WrRokV566SXNnTtXvXv3zrVPZGSkVq5cqVWrVslisahr164yDENvvfWWvc2MGTOUmJiol1566VbcRq5W7T2j/gt26O+x2tnEdPVfsEPTn6yvB2vlveIvANwOWlVspYktJip6S7TOp5637w/yCdKrjV5Vq4qtXFgd4DqEUH8KDg6WJHsQVVCJGdabWc4tkZya7OoSCszt8mVXl5Anf39/+98lAAAKauXKlUpMTNTEiRPl4+OjqKgoDRgwIM8Qat68eZo0aZJq1KghSRoyZIhmzJhhD6FOnz6t119/XV999ZVLR+pabYYiv92XLYCSJEOSSVLkt/vUukawzG4F+zIQAAqjVhVbqXFwYzVZ1ESS9MH9H6hJ2SaMgMK/GiHUn0wmk8qUKaPSpUsrM7Pgo5o+2nfJCVU5V/dNq1xdQoH5vvCCq0vIlYeHByOgAAA3ZPfu3QoPD5ePj48kqU6dOtq3b1+efS5cuKAKFSrYt81ms8O/R4MGDVLFihV14sQJ/fzzz2rSpEmu57JYLLJYLPbtpKSk672VbLbEXtSZxNxHNBuSziSma0vsRd1ducRNuy4AuNJfA6cGQQ0IoHDT/TFnri7Oneu48y+v8h95sK2Uw5tegb16qUTvXs4tLgeEUH/z9we3/Eo13X5zAHkW8lFFOfH29nZ1CQAAOE1SUpJCQ0Pt2yaTSWazWZcuXVJAQECOferXr69vvvlGYWFhslqtmj9/vlq3bi1J2rx5sxYvXqx27drpyJEjGjNmjNq0aaP3338/x3NFR0crMjLy5t+YpPPJ+XulPr/tAACAZEtJUda5c7kez8rlbS9bSoqzSsoTIRQAAEAh4e7uLi8vL4d93t7eSk1NzTWEmjZtmjp06KAtW7boyJEjOn78uObPny9Jmjlzpho3bqzly5fLZDLpmWeeUcWKFfXiiy+qWrVq2c41bNgwDR482L6dlJSkkJCQm3JvpX3z90VSftsBAADJrVgxuQcFXVc/VyCEAgAAKCQCAwO1d+9eh33Jycny9PTMtc9dd92lY8eO6cCBA+rRo4d69+5tH0118uRJtWvXzr7gSkhIiEqVKqUjR47kGEJ5eXllC8FulkahgSpT3FtnE9NznBfKJCm4uLcahQY65foAAPwTlejtmtfqrpebqwsAAADAFWFhYdq8ebN9OzY2VhaLRYGBeQczZrNZqampOnjwoEaNGmXfX758eaWlpdm3U1JSdPHiRZUrV+6m134tZjeTRna8Mnn632emuLo9smMNJiUHAOAfjBAKAACgkGjWrJmSkpI0Z84cSVJUVJRatWols9mshIQEWa25r8Y7YsQIDRkyRGXLlrXv6969u2bOnKkff/xRcXFxev7551W9enXVqVPH6feSkwdrldH0J+urtJ/jaKvg4t6a/mR9PVirjEvqAgAAtwav4wEAABQS7u7umjVrlrp3766IiAi5ublp7dq1kqSAgADt3LlTdevWzdZv3bp12rVrlxYvXuywv3Xr1ho3bpz69++vEydOqG7dulqyZIn99TxXeLBWGd1TpaRqj1otSZrbO0xN/1OKEVAAAPwLEEIBAAAUIp06ddKRI0e0fft2hYeHq0SJEpIkw8hpJqUrmjdvrjNnzuR4rE+fPurTp49Tar1efw2cGoUGEkABAPAvQQgFAABQyAQHB6t9+/auLgMAAOCmYk4oAAAAAAAAOB0hFAAAAAAAAJyOEAoAAAAAAABORwgFAAAAAAAAp2NicuAmGLvzgqtLKLDX6pV0dQkAAADAP8YnMZ9o3r55Dvv+urJph6UdZDJlXw30qRpPqWfNnk6vDygMCKEAAAAAALhBlzMv63zq+VyPx6fF59oP+LcghAL+pRIjI11dQoEVHznS1SUAAAAAOSrqUVSlfUpfVz/g34IQCgAAAACAG9SzZk9eqwOugYnJAQAAAAAA4HSEUAAAAAAAAHA6QigAAAAAAAA4HSEUAAAAAAAAnI4QCgAAAAAAAE7H6ngAAABwmlkbjmrWhliHfYYM+59bvrtWJpmy9evbNFR9m97h9PoAAMCtQwgFAAAAp0lOz9LZpPRcj59LsuTaDwAA/LO47HW8vXv3KiwsTAEBAYqIiJBhGHm2NwxD/fv3V2BgoPz9/dWrVy+lpaXdomoBAABwPXy93RXs513gj68335UCAPBP45J/3S0Wizp27Kg2bdpo0aJFeumllzR37lz17t071z7z58/XwYMHtXPnTiUlJenpp59WdHS0Ro8efQsrBwAAQEH0bXoHr9UBAABJLhoJtXLlSiUmJmrixImqXLmyoqKiNHv27Dz7bNmyRV27dlXFihVVu3Ztde7cWYcPH75FFQMAAAAAAOBGuCSE2r17t8LDw+Xj4yNJqlOnjvbt25dnn5o1a2rBggU6d+6c4uLitGjRIrVu3fpWlAsAAAAAAIAb5JIQKikpSaGhofZtk8kks9msS5cu5dqnb9++SklJUXBwsCpVqqTQ0FD17Nkz1/YWi0VJSUkOHwAAAAAAALiGS0Iod3d3eXl5Oezz9vZWampqrn0mT54sf39/xcXF6fjx48rKylJERESu7aOjo1W8eHH7JyQk5KbVDwAAAAAAgIJxSQgVGBio+Ph4h33Jycny9PTMtc/ChQsVERGhChUqKCQkRNHR0XnOIzVs2DAlJibaPydOnLhp9QMAAAAAAKBgXLI6XlhYmGbOnGnfjo2NlcViUWBgYK59bDabzp8/b98+e/asrFZrru29vLyyjbYCAAAAAACAa7gkhGrWrJmSkpI0Z84c9e7dW1FRUWrVqpXMZrMSEhLk6+srs9ns0Kdp06YaO3aszGazMjIyNG7cOHXq1MkV5QMAAAAAAKCAXBJCubu7a9asWerevbsiIiLk5uamtWvXSpICAgK0c+dO1a1b16HPmDFjlJSUpKFDhyo5OVlt2rTR5MmTb33xAAAAAAAAKDCXhFCS1KlTJx05ckTbt29XeHi4SpQoIUkyDCPH9v7+/po3b96tLBEAAAAAAAA3ictCKEkKDg5W+/btXVkCAAAAAAAAbgGXrI4HAAAAAACAfxdCKAAAAAAAADgdIRQAAAAAAACcjhAKAAAAAAAATkcIBQAAAAAAAKcjhAIAAAAAAIDTEUIBAAAAAADA6QihAAAACpG9e/cqLCxMAQEBioiIkGEYebbPzMxURESEKlSooDJlymjEiBHKysrK1i4hIUFlypTRsWPHnFQ5AABA3gihAAAACgmLxaKOHTuqQYMG2rZtm/bt26e5c+fm2ScyMlIrV67UqlWr9N1332nhwoWKjIzM1i4iIkJnz551UuUAAADXRggFAABQSKxcuVKJiYmaOHGiKleurKioKM2ePTvPPvPmzVNkZKRq1KihevXqaciQIfrmm28c2qxfv17Lli1TiRIlnFk+AABAngihAAAACondu3crPDxcPj4+kqQ6depo3759efa5cOGCKlSoYN82m80ym832bYvFon79+mnKlCkqVqxYnueyWCxKSkpy+AAAANwshFAAAACFRFJSkkJDQ+3bJpNJZrNZly5dyrVP/fr17SOfrFar5s+fr9atW9uPR0VFqWrVqnr00Uevef3o6GgVL17c/gkJCbmBuwEAAHDk7uoCAAAAcIW7u7u8vLwc9nl7eys1NVUBAQE59pk2bZo6dOigLVu26MiRIzp+/Ljmz58vSdq/f79mzJihnTt35uv6w4YN0+DBg+3bSUlJBFEAAOCmIYQCAAAoJAIDA7V3716HfcnJyfL09My1z1133aVjx47pwIED6tGjh3r37q3Q0FAZhqFnn31WY8aMUdmyZfN1fS8vr2whGAAAwM3C63gAAACFRFhYmDZv3mzfjo2NlcViUWBgYJ79zGazUlNTdfDgQY0aNUqSdPz4cW3cuFERERHy9/eXv7+/jh8/rjp16ujTTz915m0AAADkiJFQAAAAhUSzZs2UlJSkOXPmqHfv3oqKilKrVq1kNpuVkJAgX19fh0nH/2rEiBEaMmSIfdRTuXLlFBsb69Dm3nvv1aJFi1S3bl1n3woAAEA2hFAAAACFhLu7u2bNmqXu3bsrIiJCbm5uWrt2rSQpICBAO3fuzDFAWrdunXbt2qXFixc7nKtSpUrZzl++fPlrrpIHAADgDIRQAAAAhUinTp105MgRbd++XeHh4SpRooQkyTCMXPs0b95cZ86cuea5jx07drPKBAAAKDBCKAAAgEImODhY7du3d3UZAAAANxUTkwMAAAAAAMDpCKEAAAAAAADgdIRQAAAAAAAAcDpCKAAAAAAAADgdIRQAAAAAAACcjhAKAAAAAAAATkcIBQAAAAAAAKcjhAIAAAAAAIDTEUIBAAAAAADA6QihAAAAAAAA4HSEUAAAAAAAAHA6QigAAAAAAAA4HSEUAAAAAAAAnI4QCgAAAAAAAE5HCAUAAAAAAACnI4QCAAAAAACA0xFCAQAAAAAAwOkIoQAAAAAAAOB0hFAAAAAAAABwOkIoAAAAAAAAOB0hFAAAAAAAAJyOEAoAAAAAAABORwgFAAAAAAAApyOEAgAAAAAAgNMRQgEAAAAAAMDpCKEAAAAAAADgdIRQAAAAAAAAcDpCKAAAAAAAADgdIRQAAAAAAACcjhAKAAAAAAAATkcIBQAAAAAAAKcjhAIAAAAAAIDTEUIBAAAAAADA6QihAAAAAAAA4HSEUAAAAIXI3r17FRYWpoCAAEVERMgwjDzbZ2ZmKiIiQhUqVFCZMmU0YsQIZWVl2Y9HRkYqMDBQXl5e6tKli5KTk519CwAAADkihAIAACgkLBaLOnbsqAYNGmjbtm3at2+f5s6dm2efyMhIrVy5UqtWrdJ3332nhQsXKjIyUpK0cOFCLVy4UKtWrVJMTIz279+vsWPH3oI7AQAAyI4QCgAAoJBYuXKlEhMTNXHiRFWuXFlRUVGaPXt2nn3mzZunyMhI1ahRQ/Xq1dOQIUP0zTffSJJOnDihTz75RI0aNVKVKlX06KOPaufOnbfiVgAAALJxd3UBAAAAuGL37t0KDw+Xj4+PJKlOnTrat29fnn0uXLigChUq2LfNZrPMZrMk6bXXXnNoe/DgQf3nP//J9VwWi0UWi8W+nZSUVOB7AAAAyA0joQAAAAqJpKQkhYaG2rdNJpPMZrMuXbqUa5/69evbRz5ZrVbNnz9frVu3ztbu0KFDWrp0qZ599tlczxUdHa3ixYvbPyEhITdwNwAAAI4IoQAAAAoJd3d3eXl5Oezz9vZWampqrn2mTZumTz75RA888ICqVq2qX3/9Vf3793doY7PZ9PTTT6tv376qWbNmrucaNmyYEhMT7Z8TJ07c2A0BAAD8Ba/jAQAAFBKBgYHau3evw77k5GR5enrm2ueuu+7SsWPHdODAAfXo0UO9e/d2GE0lSW+99ZYuXryo8ePH53l9Ly+vbCEYAADAzUIIBQAAUEiEhYVp5syZ9u3Y2FhZLBYFBgbm2c9sNis1NVUHDx7U8uXLHY59++23mjhxon755Rf7XFMAAACuwOt4AAAAhUSzZs2UlJSkOXPmSJKioqLUqlUrmc1mJSQkyGq15tp3xIgRGjJkiMqWLWvft3//fnXv3l1Tp05VSEiIUlJS8ny1DwAAwJkIoQAAAAoJd3d3zZo1Sy+88IJKliypb775RuPGjZMkBQQEaM+ePTn2W7dunXbt2qWhQ4c67P/oo490+fJl9ezZU76+vvL19VWNGjWcfh8AAAA54XU8AACAQqRTp046cuSItm/frvDwcJUoUUKSZBhGrn2aN2+uM2fOZNs/adIkTZo0yWm1AgAAFAQhFAAAQCETHBys9u3bu7oMAACAm4rX8QAAAAAAAOB0hFAAAAAAAABwOkIoAAAAAAAAOB0hFAAAgJNkZmZq3rx5ri4DAACgUCCEAgAAuAH333+/bDabVqxYYd83btw4bdiwQTabTePHj3dhdQAAAIWHy0KovXv3KiwsTAEBAYqIiMhz2eG/stlsatKkiSZMmODkCgEAAK7t2LFj2r59u3r06KGffvpJ+/bt05QpU1ShQgV5eXnJbDa7ukQAAIBCwSUhlMViUceOHdWgQQNt27ZN+/bt09y5c/PVd8aMGUpMTNRLL73k3CIBAADyITAwUGFhYVq+fLnefvttHTlyRNOmTbMfd3Nj4DkAAIAkubvioitXrlRiYqImTpwoHx8fRUVFacCAAerdu3ee/U6fPq3XX39dX331lTw8PG5RtQAAALkzmUySpICAAP344486d+6cunbtqlKlSumrr77K92hvAACAfzqXhFC7d+9WeHi4fHx8JEl16tTRvn37rtlv0KBBqlixok6cOKGff/5ZTZo0ybWtxWKRxWKxbyclJd144QAAADmwWq3q1KmTXnzxRfn6+iolJUWzZs2S9P8hFQAAwL+dS8aHJyUlKTQ01L5tMplkNpt16dKlXPts3rxZixcvVvny5XXkyBH17NlTL7zwQq7to6OjVbx4cfsnJCTkpt4DAAD4dzt16pQ6dOigS5cuKT4+XuvWrdNnn30mLy8vPf3004qIiNBTTz2l48eP66mnntKjjz7q6pIBAABcyiUhlLu7u7y8vBz2eXt7KzU1Ndc+M2fOVOPGjbV8+XKNHj1aP/30kz744AMdPHgwx/bDhg1TYmKi/XPixImbeg8AAODfrWjRoqpZs6bc3NzUuHFjrVixQvfee68mTZqkgwcPqnjx4mrQoIG8vb3VoEEDNWjQwNUlAwAAuJRLQqjAwEDFx8c77EtOTpanp2eufU6ePKl27drZh7SHhISoVKlSOnLkSI7tvby85Ofn5/ABAAC4Wfz9/TVu3Dj5+flpxYoVWrJkiRYtWqThw4dr9erVCg0N1cCBA1WqVCkNHDhQQ4cOdXXJAAAALuWSECosLEybN2+2b8fGxspisSgwMDDXPuXLl1daWpp9OyUlRRcvXlS5cuWcWisAAEBeTCaTatWqpVWrVqlr166qVKmS3nrrLVWuXNnVpQEAABQqLgmhmjVrpqSkJM2ZM0eSFBUVpVatWslsNishIUFWqzVbn+7du2vmzJn68ccfFRcXp+eff17Vq1dXnTp1bnX5AAAAdhkZGZKk6dOny2w2Kz09XTNmzFDPnj0lMTE5AADAVS6bE2rWrFl64YUXVLJkSX3zzTcaN26cpCvLG+/Zsydbn9atW2vcuHHq37+/qlevrt9//11LlizhwQ4AALhUfHy8Tp48qcjISD333HNq3LixAgICNGTIEFmtVmVmZrq6RAAAgELB3VUX7tSpk44cOaLt27crPDxcJUqUkCQZhpFrnz59+qhPnz63qkQAAIBrGj9+vMqXL6+YmBiVLFlSkhQZGamtW7fKYrEoPT3dxRUCAAAUDi4LoSQpODhY7du3d2UJAAAAN+Txxx+XJHsAJUm1a9dW7dq1JUlbt251SV0AAACFjUtDKAAAgH+KrVu3Ki0tTe7uOT9elS1bVpUqVbq1RQEAABQihFAAAAA3wfPPP69ixYpJknbs2KH69etr9+7duuuuu2QYhg4fPqyjR4/K09PTxZUCAAC4BiEUAADADXj00Uc1ZcoUSdKaNWskSY0aNdKaNWvUsmVL+745c+YoJSVFgYGBLqsVAADAlQihAAAAbsBPP/2kJk2a6OLFi/r4448lSRcuXNDHH3+ss2fP2vdVr16dAAoAAPyrEUIBAABch/Pnz8vb21uhoaH6/vvv1bBhQ/3++++SpPT0dP3+++9KTU217yOAAgAA/3aEUAAAANdh8eLFio6OVqlSpRQQEKDAwEBFR0dLkn788UdFR0fr119/te8DAAD4tyOEAgAAuA4DBgxQqVKlNGjQIL3xxhtyc3NTxYoVZRiG4uPjVbp0aSUkJKhOnTp6/PHH9fLLL8vLy8vVZQMAALiMm6sLAAAAuF1169ZNmzZt0o8//qi+ffsqLi5Ox48fV1pamk6dOqW4uDiNGDFC27ZtU8uWLV1dLgAAgEsxEgoAAOA6HTt2TF26dNHPP/+sjIwMjRkzRt988408PDzsbTIyMtSwYUNFRES4sFIAAADXI4QCAAC4Th4eHrJYLDIMQ/7+/jp16pS6deumhx9+WJJkGIY6dOigyMhIBQUFubhaAAAA1yKEAgAAuAFxcXGqWLGimjRpovj4ePn4+OjgwYP24+np6dq+fbuCgoLUoEEDF1YKAADgWoRQAAAA18lqterOO+/Ur7/+ql9//VWzZ8/W1KlTNWfOHHXq1Ekmk0ktW7bUokWLVKtWLUIoAADwr0YIBQAAcJ18fX3Vt29fubu765577tE999yjl19+Wd27d1e3bt3Url07V5cIAABQaBBCAQAAXKeAgAD179/fYV/t2rW1bds2eXt7u6gqAACAwsnN1QUAAADc7tavX++w/dcAKisrS0899ZSysrJudVkAAACFSoFCqNWrV0u6stLLVbGxscrMzFRqaqoaNWp0c6sDAAAo5AzDUOfOnSVdmYS8cePGkqS7775bkuTm5qaFCxfKbDa7qkQAAIBCoUAhVK9evbRz5041a9ZMmZmZslqteuSRR7R06VJ5eXnJYrE4q04AAIBCyWQy2Uc+eXp66ty5c5KkpKQkSVdCKMMwZDKZXFYjAABAYVCgEKpEiRKqVauWypYtq0cffVSzZ89WtWrV1K1bN5nNZr7hAwAA/yqzZs3S+PHjZTKZtHTpUi1dulRpaWn66quvlJaWpqVLl+rLL78sUAC1d+9ehYWFKSAgQBEREQ4j0HOSmZmpiIgIVahQQWXKlNGIESMcXv1bsmSJKlasqLJly+qzzz677nsFAAC4UQUKoYoUKSIPDw8tXLhQTz/9tLp3766OHTtq7NixknTNhyQAAIB/ip07dyoyMlKtW7dWSkqKpk6dqvfff1/JycmaOnWq4uPjNWXKFL3//vv5PqfFYlHHjh3VoEEDbdu2Tfv27dPcuXPz7BMZGamVK1dq1apV+u6777Rw4UJFRkZKuhJoPfHEE3rzzTf1/fffa8SIETp48OCN3DYAAMB1u66JyV988UXVr19fy5cvV8+ePeXn53ez6wIAACjU6tWrp927d6tu3boKDAzUTz/9pDVr1ig4OFhr1qxRlSpVtGbNGq1Zsybf51y5cqUSExM1ceJEVa5cWVFRUZo9e3aefebNm6fIyEjVqFFD9erV05AhQ/TNN99IujJSq2XLlurbt69q166tF154QfPnz7+h+wYAALhe+Q6htm/fLovFIpvNJj8/P3Xo0EE1atTQyy+/rDvuuENHjx5VZmamYmNjtX//fmfWDAAA4HIWi0WvvPKKtm/fnuPrdtczB9Tu3bsVHh4uHx8fSVKdOnW0b9++PPtcuHBBFSpUsG//dYqE3bt367777rMfa9SokbZv357ruSwWi5KSkhw+AAAAN4t7fhrFxMTo3nvvVUhIiMaMGaPXXntN6enpGjhwoLp166auXbvKw8NDKSkpql+/vjIyMnT58mVn1w4AAOAy586dU2Jiolq0aKG0tDR7EHTmzBlVqFBB586ds+8zDEMVKlTQ8ePH8zxnUlKSQkND7dsmk0lms1mXLl1SQEBAjn3q16+vb775RmFhYbJarZo/f75at26d4/n8/Px0+vTpXK8fHR1tf5UPAADgZstXCFWjRg2dOXNGzZo1U0xMjFq0aKHq1aurZcuWmjRpkiZMmKB+/fqpXr162rlzp7NrBgAAcLkKFSroyy+/VHJysj7++GNNmDBBqampmjRpkpo2berQ1mq1Kj09/ZrndHd3l5eXl8M+b29vpaam5hpCTZs2TR06dNCWLVt05MgRHT9+3P7K3d/Pd/VcuRk2bJgGDx5s305KSlJISMg16wYAAMiPfIVQJpNJ/v7+8vb21ueff67169erU6dO6tq1q+6//35t3rxZ/fr1c3atAAAAhY6vr6969+6tp59+Wu+8847Onz+vWrVqXdeqwYGBgdq7d6/DvuTkZHl6euba56677tKxY8d04MAB9ejRQ71797aPfgoMDFR8fHy+z+Xl5ZUtBAMAALhZ8hVCXXV19btq1app7ty5qlmzpi5duqSePXtKur65DwAAAG5n58+fV+vWrXXfffdp0qRJkqT27dvLbDbrueeeU9u2bfP9jBQWFqaZM2fat2NjY2WxWBQYGJhnP7PZrNTUVB08eFDLly93ON/mzZvVp08fSVdW9CtXrlxBbxEAAOCmKNDqeImJiUpOTlabNm20e/dulSxZUmPHjtXhw4cl/X9IBQAA8G9w4sQJ3XvvvapXr57eeecd+/4lS5bokUce0euvv67KlSvbw6lradasmZKSkjRnzhxJUlRUlFq1aiWz2ayEhARZrdZc+44YMUJDhgxR2bJl7fseeeQRLVq0SHv27FFKSoqmTJmiNm3aXOfdAgAA3JgChVA+Pj4ymUx66KGHNHLkSAUEBOjll1/WwIEDlZGRka+5DgAAAP4pvL299cwzz2ju3Lny8PCw7y9SpIh69uypnTt36vXXX9fRo0fzdT53d3fNmjVLL7zwgkqWLKlvvvlG48aNkyQFBARoz549OfZbt26ddu3apaFDhzrsv+uuuzRw4EA1bNhQ5cqVk9ls1vPPP3+ddwsAAHBjCvQ63q5duyTJYdWUfv366dlnn5UkPfbYYzevMgAAgEKuVKlSioiIyPW4yWRS3759C3TOTp066ciRI9q+fbvCw8NVokQJSXmPOG/evLnOnDmT47G3335bTzzxhE6dOqXmzZvnOScUAACAMxVoJFROPD095eXlJU9PT40cOfJm1AQAAHBbyMzMVPv27e3bhmE4zOl0VUZGRoEm/A4ODlb79u3tAdSNqlGjhlq3bk0ABQAAXKpAI6GueuaZZ3TkyBG5u+fc/c4779TkyZNvqDAAAIDCzs3NTevXr7dvm0wmvfjii3rmmWcc2nl6esrb2/tWlwcAAFCoFGgk1NV5CHbt2qWRI0fq9ddf14kTJ/TGG28oPj5eb7zxhoYNG6Zdu3bp9OnTTikYAACgsDCbzQ5zQUlX5oPKrS0AAMC/WYFGQjVs2FAvvfSSUlNT1bx5c0mSr6+vmjdvroCAAPu+OnXq3LTh4wAAAIWZxWLRvHnz7NsZGRkO2wAAALiiQCFU9erV5efnp6NHj6pChQoyDEPx8fGqUKGC/X8l6fHHH9fYsWOdUjAAAEBhkpmZqSVLltgnDr/vvvu0ePFiF1cFAABQ+OQrhFq1apViYmLk5eWlN998U8uWLdOmTZtks9nUtGlTbdy4UQ888IBWr1595aS5zBUFAADwT1OsWDEtW7bsmu0CAwNvQTUAAACFV77SIj8/P82fP19nzpzRsWPHJEmzZs2SJMXHx2v27Nk6c+aMvvvuOz3wwAMFWv0FAADgdmWz2ZSVlWXfPn78uAYPHswqdAAAADnIVwjVpEkTbd++XWPGjFHz5s3VpUsXpaSkSLqyUt6pU6fUsmVLvfnmm3r22Wc1depUPfbYY04tHAAAwNUyMzOVkZFh3/b19dWDDz4od3d3mUwm+36bzabvvvvOFSUCAAAUGvl+by4xMVG+vr5655135OfnpzJlyujUqVMOK8J06NBBJ0+e1JIlSwihAADAP56Xl5fDisABAQHq27evfXvz5s3asmWL+vXrp/79+7uiRAAAgEIj3yFUamqqPv30U23btk2S1L9/f+3Zs0ehoaH2NitWrNAbb7yhJUuW3PxKAQAACqE5c+aoRYsWatCggeLi4pSSkmL/km7btm0aPny4Vq9erd9//93FlQIAALhWvkMok8mk33//XW+88YYeeeQRmUwmPfvss3rqqafsberUqaMhQ4Y4pVAAAIDCxDAMPfnkk9q0aZPuvfdeSdLQoUO1ZcsWh3YlS5bUhg0bdO+99+rHH39UlSpVXFEuAACAyxVoGbuSJUuqaNGievXVV7V+/Xp9//33ev/99+3HDx8+rEaNGqlp06aaMGHCTS8WAACgsDCZTGrfvr2mTJmiEiVKSLqyUl5sbGy2tlarVUuXLiWAAgAA/2r5DqEsFouKFSum119/Xa+//rpiY2M1bNgwff/995o+fbruvvtuSVcesv46TxQAAMA/1eOPP+6wndsKwWazWV27dr0VJQEAABRa+Q6h7rjjDu3evdu+HRoaqkWLFmnevHl64IEHFBgYKEk6evSoQkJCbn6lAAAAhdwHH3zg6hIAAAAKLbeCNLbZbGrbtq0kKSsrS4sXL9ZTTz2lH374QdKVZYr/85//KCsr6+ZXCgAAUIht2bIl19WBDcPQmjVrbnFFAAAAhUuBQig3Nzdt375d0pWHqcGDB0uS3njjDUmSu7u7DMOQu3uBppoCAAC47Y0ePVpVqlRRSkqK+vfvr59++kkWi0XSleemJ554wsUVAgAAuFa+Q6jk5GQdO3ZMRYsWlSR5eHjIbDZLkry9vSVdmaDTZDI5oUwAAIDCa+zYsUpPT9eqVauUlZWl4OBgTZo0SdWrV9cDDzygCRMm8CUdAAD418vX09DZs2fVqlUrde7cWX/88Yfq1Klj31+nTh0dPXpUderUkWEYTi0WAACgMNm/f7/GjBmjCxcuaOnSpQoJCZG/v79GjhyphIQEHTp0SFarVZs2bXJ1qQAAAC6Xr5FQJpNJPXr00JgxY+Tr66upU6dqypQpCgwM1NSpU1W2bFlNnTpVU6dOdXa9AAAAhYJhGLr77ruVmpqq77//Xr6+vjKZTDp8+LCCgoJUr149jR49WiVLltQrr7zi6nIBAABcLl8hVFBQkLp16ybpytLDzZs3V4sWLeTt7a3mzZurWLFi9n0AAAD/FrNnz9bFixfVokULHT58WFlZWbrjjjt06NAhrV+/Xt27d9enn37q6jIBAAAKhXy9jnfo0CHVqFFDbdu2VXJysubMmSPDMJSSkqKPP/5YFy9etO8zDENz5sxR7969nV07AACAy5hMJj3yyCN65JFH9MUXX6hVq1Zq37693Nzc9MADD8hsNqtp06aqX7++srKyZLPZXF0yAACAS+UrhKpatap27NihJUuWaNu2berTp49KlCihe++9V99++63q16+vZcuWSZI6dOigRYsWEUIBAIB/jW7duumuu+5Sly5dlJ6erjlz5igoKEj+/v4ym83KysrSwIEDXV0mAACAS+V7mZY6deqoTp06evPNN/XRRx9p1KhRCgoK0owZM5xZHwAAQKHWs2dPhYSEKDg4WMOGDdP27dvVrl07BQQE6PLly7LZbPLx8VG1atXUp08fBQYGurpkAAAAl8jXnFB/NX/+fIWGhmrv3r16+eWX9cUXX2jHjh3OqA0AAKDQW7lypcqVK6cLFy7o559/1oQJE5Senq5jx45p5syZ+vbbb3Xw4EFdunRJK1eudHW5AAAALlOgEGrixIkaPHiwMjMzFRQUpGrVquncuXN69NFHFRYWprlz58pisTirVgAAgEKnWLFi6tmzp0aNGqXp06frq6++UtGiRSVJcXFx+vjjj+Xj46OwsDAVK1bMxdUCAAC4Tr5DqG3btmnChAlav369HnroIfv+F198UYcOHdKrr76qt99+W40bN3ZKoQAAAIWN1WpVenq63njjDfn6+qp06dIKCgpSUlKSpCvzav7444+SpBkzZjg8QwEAAPzb5DuEatiwofbv3686depkO2YymdS1a1fFxMSwDDEAAPjXMAxDgwYN0qRJk5ScnKzz58/rzJkzSkxMlCTdcccdatq0qVJTU11cKQAAgOvle2JySfLz88vzuKenp2rUqHFDBQEAANwu3N3dNXToUId9bm5u9tfxqlWrpnnz5kmSsrKy5O5eoEcvAACAf5QCT0wOAACAgmvatKl+/vlnV5cBAADgMoRQAAAA18lms+mnn35SVlZWnu1+//13/frrr7p8+fItqgwAAKDwIYQCAAC4TpmZmWrVqpVKlCihJ598UmvXrs2x3YoVKxQUFKT777//1hYIAABQiBBCAQAA3AAfHx/NnTtXXl5e6ty5s2rWrKmvvvrKoc2cOXPUp08fubnx6AUAAP69eBICAAC4AW5uburSpYtmz56tU6dO6fnnn9eAAQPUokULnThxQl9//bWOHTumgQMHurpUAAAAl2KJFgAAgJvAZrNp9uzZKlu2rH7//XcNHjxYd911lzw9PRUVFaVSpUq5ukQAAACXYiQUAADADbJYLKpfv77ef/99eXh4qFixYnriiSckSZcvX9bjjz/u4goBAABcjxAKAADgBnl5eemNN95QTEyM6tSpo6eeekoPPPCAXnjhBbVt21b9+/fP97n27t2rsLAwBQQEKCIiQoZh5NneMAz1799fgYGB8vf3V69evZSWlnbNYwAAALcaIRQAAMANslgscnd3V7du3VS9enUlJydr+/btGj16tKZPn67//e9/+uGHH/J1no4dO6pBgwbatm2b9u3bp7lz5+bZZ/78+Tp48KB27typDRs2KCYmRtHR0dc8BgAAcKsRQgEAAFwnwzB0+fJllSxZUq+++qpq1KihAwcOaOnSpapVq5YkqUSJEho8eLBGjBhxzfOtXLlSiYmJmjhxoipXrqyoqCjNnj07zz5btmxR165dVbFiRdWuXVudO3fW4cOHr3kMAADgViOEAgAAuE5Wq1Xu7u7atGmTDh06pLfffluhoaHZ2j333HPasWOHduzYkef5du/erfDwcPn4+EiS6tSpo3379uXZp2bNmlqwYIHOnTunuLg4LVq0SK1bt77msZxYLBYlJSU5fAAAAG4WQigAAIDrlJmZqZCQENWpUyfPdiVKlFCbNm00b968PNslJSU5hFgmk0lms1mXLl3KtU/fvn2VkpKi4OBgVapUSaGhoerZs+c1j+UkOjpaxYsXt39CQkLyrBcAAKAgCKEAAACuk7+/f75fbxs0aJCGDh2aZxt3d3d5eXk57PP29lZqamqufSZPnix/f3/FxcXp+PHjysrKUkRExDWP5WTYsGFKTEy0f06cOJGvewMAAMgPl4VQBV355a8SEhJUpkwZHTt2zHkFAgAA5ENSUpIqVqwom80mSdq6dWu2NmlpaZowYYLc3PJ+9AoMDFR8fLzDvuTkZHl6eubaZ+HChYqIiFCFChUUEhKi6Oho+zxSeR3LiZeXl/z8/Bw+AAAAN4tLQqjrWfnlryIiInT27FnnFQgAAJBPxYoV0x9//CE3NzctWbJEzZo10+nTpx3aHDp0SCtXrpTJZMrzXGFhYdq8ebN9OzY2VhaLRYGBgbn2sdlsOn/+vH377Nmzslqt1zwGAABwq7m74qJ/XfnFx8dHUVFRGjBggHr37n3NvuvXr9eyZctUokSJW1ApAABA3tzc3OTj46O4uDg9++yzGj16tMqUKePQZuPGjapZs6aCgoLyPFezZs2UlJSkOXPmqHfv3oqKilKrVq1kNpuVkJAgX19fmc1mhz5NmzbV2LFjZTablZGRoXHjxqlTp07XPAYAAHCruSSEup6VX6QrI6j69eunKVOm6NVXX3V2mQAAAPliGIaeeeYZtWvXTocOHVLTpk31ySefqHLlypKkL7/8Uk888cQ1z+Pu7q5Zs2ape/fuioiIkJubm9auXStJCggI0M6dO1W3bl2HPmPGjFFSUpKGDh2q5ORktWnTRpMnT77mMQAAgFvNJSFUXiu/BAQE5NovKipKVatW1aOPPnrNEMpischisThcEwAAwFnGjRunKlWqKD09XWPHjlWjRo00a9YslStXTjt27NDSpUvzdZ5OnTrpyJEj2r59u8LDw+2jv3ObP9Pf3z/XVffyOgYAAHCruSSEymvll9xCqP3792vGjBnauXNnvq4RHR2tyMjIG64VAAAgJwkJCZozZ44uX74sk8mkevXqSZJ8fX01YcIEdenSRd26dZNhGHr77bdVvHjxfJ87ODhY7du3d1bpAAAALuGSickLuvKLYRh69tlnNWbMGJUtWzZf12CJYQAA4Ezff/+93nzzzVxHW5ctW1alS5dWfHy8WrRocWuLAwAAKIRcEkIVdOWX48ePa+PGjYqIiJC/v7/8/f11/Phx1alTR59++mmOfVhiGAAAOFOnTp10+vRpvfPOOzIMQ8ePH1dqaqrOnj2riIgI3XXXXWrbtq0mTJigvn37urpcAAAAl3PJ63gFXfmlXLlyio2NdTjHvffeq0WLFmWbnBMAAOBWKFKkiIoUKWLffu6552QymfTcc89pz549WrNmjRo2bChJmj17tr755hs99NBDrioXAADA5Vw2J1RBVn5xd3dXpUqVsp2jfPnyKlas2K0rHAAAIAcmk0nTp0/X/fffr++++06rVq1yON6/f39NnjyZEAoAAPyruSSEkgq+8svfHTt2zInVAQAA5F9WVpYqVqyo1atXq3HjxqpVq5YGDBhgP96xY0e9+OKLOnfunIKCglxYKQAAgOu4LISSWPkFAADc/lJSUuxfpt1xxx366KOPVLVqVYc25cuXV5UqVXTs2DFCKAAA8K/l0hAKAADgdlesWDH9/vvv9u0uXbrk2G7Xrl3y9va+VWUBAAAUOi5ZHQ8AAODfhgAKAAD82xFCAQAAAAAAwOkIoQAAAAAAAOB0hFAAAAAAAABwOkIoAAAAAAAAOB0hFAAAAAAAAJyOEAoAAAAAAABORwgFAAAAAAAApyOEAgAAAAAAgNMRQgEAAAAAAMDpCKEAAAAAAADgdIRQAAAAAAAAcDpCKAAAAAAAADgdIRQAAAAAAACcjhAKAAAAAAAATkcIBQAAAAAAAKcjhAIAAAAAAIDTEUIBAAAAAADA6QihAAAAAAAA4HSEUAAAAAAAAHA6QigAAAAAAAA4HSEUAAAAAAAAnI4QCgAAAAAAAE5HCAUAAAAAAACnI4QCAAAAAACA0xFCAQAAAAAAwOkIoQAAAAAAAOB0hFAAAACFyN69exUWFqaAgABFRETIMIw82xuGof79+yswMFD+/v7q1auX0tLSHNrYbDY1adJEEyZMcGbpAAAAeSKEAgAAKCQsFos6duyoBg0aaNu2bdq3b5/mzp2bZ5/58+fr4MGD2rlzpzZs2KCYmBhFR0c7tJkxY4YSExP10ksvObF6AACAvBFCAQAAFBIrV65UYmKiJk6cqMqVKysqKkqzZ8/Os8+WLVvUtWtXVaxYUbVr11bnzp11+PBh+/HTp0/r9ddf19SpU+Xh4eHsWwAAAMgVIRQAAEAhsXv3boWHh8vHx0eSVKdOHe3bty/PPjVr1tSCBQt07tw5xcXFadGiRWrdurX9+KBBg1SxYkWdOHFCP//8c57nslgsSkpKcvgAAADcLIRQAAAAhURSUpJCQ0Pt2yaTSWazWZcuXcq1T9++fZWSkqLg4GBVqlRJoaGh6tmzpyRp8+bNWrx4scqXL68jR46oZ8+eeuGFF3I9V3R0tIoXL27/hISE3LybAwAA/3qEUAAAAIWEu7u7vLy8HPZ5e3srNTU11z6TJ0+Wv7+/4uLidPz4cWVlZSkiIkKSNHPmTDVu3FjLly/X6NGj9dNPP+mDDz7QwYMHczzXsGHDlJiYaP+cOHHi5t0cAAD41yOEAgAAKCQCAwMVHx/vsC85OVmenp659lm4cKEiIiJUoUIFhYSEKDo62j6P1MmTJ9WuXTuZTCZJUkhIiEqVKqUjR47keC4vLy/5+fk5fAAAAG4WQigAAIBCIiwsTJs3b7Zvx8bGymKxKDAwMNc+NptN58+ft2+fPXtWVqtVklS+fHmlpaXZj6WkpOjixYsqV66cE6oHAADIm7urCwAAAMAVzZo1U1JSkubMmaPevXsrKipKrVq1ktlsVkJCgnx9fWU2mx36NG3aVGPHjpXZbFZGRobGjRunTp06SZK6d++u7t27q1WrVqpSpYrefPNNVa9eXXXq1HHF7QEAgH85QigAAIBCwt3dXbNmzVL37t0VEREhNzc3rV27VpIUEBCgnTt3qm7dug59xowZo6SkJA0dOlTJyclq06aNJk+eLElq3bq1xo0bp/79++vEiROqW7eulixZYn89DwAA4FYihAIAAChEOnXqpCNHjmj79u0KDw9XiRIlJEmGYeTY3t/fX/Pmzcv1fH369FGfPn2cUisAAEBBEEIBAAAUMsHBwWrfvr2rywAAALipmJgcAAAAAAAATkcIBQAAAAAAAKcjhAIAAAAAAIDTEUIBAAAAAADA6QihAAAAAAAA4HSsjgcAAADgn+Xn96XN0wre7+4BUpMXbn49AABJhFAAAAAA/mksyVLy6evrBwBwGkIoAAAAAP8sXr6Sb9m/7TSk5DNX/uhbRpIp534AAKchhAIAAADwz9Lkheyv1WVclqL+DKZe3C55Fr31dQHAvxwTkwMAAAAAAMDpCKEAAAAAAADgdIRQAAAAAAAAcDpCKAAAAAAAADgdIRQAAAAAAACcjhAKAAAAAAAATkcIBQAAAAAAAKcjhAIAAAAAAIDTEUIBAAAAAADA6QihAAAAAAAA4HSEUAAAAAAAAHA6QigAAAAAAAA4HSEUAAAAAAAAnI4QCgAAAAAAAE5HCAUAAAAAAACnI4QCAAAAAACA07m7ugAAAADc3qxWqzIzM11dBm4CDw8Pmc1mV5cBAPiHIoQCAADAdTEMQ2fPnlVCQoKrS8FN5O/vr+DgYJlMJleXAgD4hyGEAgAAwHW5GkCVLl1aPj4+hBa3OcMwlJqaqvPnz0uSypQp4+KKAAD/NIRQAAAAKDCr1WoPoEqUKOHqcnCTFClSRJJ0/vx5lS5dmlfzAAA3FROTAwAAoMCuzgHl4+Pj4kpws139nTLPFwDgZnPZSKi9e/eqd+/eOnz4sPr27at33nnnmkO4IyMjNXnyZF2+fFnt2rXTvHnz5Ovre4sqBgAAwN8V5BW8WRuOataG2AJfo2/TUPVtekeB+93uDMPI9vOdO3eu2rdvr1KlSjnturxWCQBwFpeMhLJYLOrYsaMaNGigbdu2ad++fZo7d26efRYuXKiFCxdq1apViomJ0f79+zV27NhbUzAAAABuWHJ6ls4mpRf4k5yeddNr2bp1q1q2bKnU1FSH/efOnZO/v3+OfdLT0/Xiiy8qMTFRknT58mVZrdZcr5GRkSGTyaTAwECVLFkyz4+np6cmT57s0L99+/ZaunSpffu3337TgAEDGKEEALhtuWQk1MqVK5WYmKiJEyfKx8dHUVFRGjBggHr37p1rnxMnTuiTTz5Ro0aNJEmPPvqotm7deqtKBgAAwA3y9XZXsJ+3wz6bYdP55AxJUoCPhzzNbtlG4vh63/xH1rCwMD300EM6efKkqlatqgkTJsgwDKWlpclqterdd9+VJJUqVUo9e/aUJM2fP1979uyxj8SvWrWqzGaz3NyufK976tQpvfnmmxoxYoQkydPTU15eXtqxY4cqVaokSUpLS7PPuyRdCao8PT3VoUMHFStWzL7/9OnT+uWXXzRv3jz7vgULFshqtapJkyb2feXKldP69euZuwkAcFtwSQi1e/duhYeH2983r1Onjvbt25dnn9dee81h++DBg/rPf/6Ta3uLxSKLxWLfTkpKuoGKAQAAcKP6Nr3D4bW6VXvPaOSyGPv2pdRMlSnurZEda+jBWs5Zme3IkSNq0KCBihcvLsMwFBkZqT179uiNN97Qd999Zw+FwsPDtXPnTk2ZMkU9e/ZUamqqJkyYoJUrVyo5OVn79u3TqVOn7Of9+uuv9c4772jYsGEO13N3d9fvv/+uX375RY899pjee+89bd++XUuWLJEkjRw50h5i/TVImjp1qgYNGqSkpCRNmTJFAwYM0IwZM1S9enXt2rVLhmEoPDxcPXv2JIACANw2XPI6XlJSkkJDQ+3bJpNJZrNZly5dylf/Q4cOaenSpXr22WdzbRMdHa3ixYvbPyEhITdcNwAAgLPt3btXYWFhCggIUEREhAzDyLO9YRjq37+/AgMD5e/vr169eiktLS1bu4SEBJUpU0bHjh1zUuUFs2rvGfVfsEPnkiwO+88mpqv/gh1atfeMU65buXJlJSQkKC4uTm+88YaqV6+u8uXLy8PDQ02aNFF4eLg8PDx07733qnbt2nJ3v/Kd7ZAhQzR48GCFhoYqIiLCPtpJklasWKHu3bsrMjJSHh4e2a7p5eWlgQMHKi4uTmvXrlWzZs3UsGFDJScna+3atapfv75D+3379unTTz/V4MGD9cEHH+jAgQPq3bu3BgwYoMDAQH366af68MMPJUl9+/Z1ys8JAABncEkI5e7uLi8vL4d93t7e2d7Jz4nNZtPTTz+tvn37qmbNmrm2GzZsmBITE+2fEydO3HDdAAAAznQ982bOnz9fBw8e1M6dO7VhwwbFxMQoOjo6W7uIiAidPXvWSZUXjNVmKPLbfcopXru6L/LbfbLa8g7gbkRmZqYmTJig/v37S5J9NNLfmUwmbdiwQR999JFmzZqlO++8U8uXL9fChQtls9k0fvx4DR8+XEuWLNGAAQM0cuTIbHM2VahQQW+++aYGDBigXbt26dlnn9V//vMfvf766zp06JA6dOjg0P6VV15RYmKi7rnnHs2ZM0fjx4/Xgw8+qMjISL333nt68cUXNXr0aH3++ee51g0AQGHkkn+1AgMDFR8f77AvOTlZnp6e1+z71ltv6eLFixo/fnye7by8vOTn5+fwAQAAKMz+Om9m5cqVFRUVpdmzZ+fZZ8uWLeratasqVqyo2rVrq3Pnzjp8+LBDm/Xr12vZsmUqUaKEM8vPty2xF3UmMT3X44akM4np2hJ70Wk1jB8/XgkJCXr00UclXQmbgoODVbFiRZ0/f17+/v72cKhJkybaunWrFi9erPT0dC1cuFAbNmxQ1apVtWnTJq1du1bt27fXxo0btXr1ajVt2lQ2m83hev3799exY8f04IMPytvbW2PHjtVHH32kLl26ZPtydsqUKTp06JBatWqlQYMGqWLFinrppZd07tw5ffDBBypWrJiysrK0YMECnTnjnBFjAAA4g0tCqLCwMG3evNm+HRsbK4vFosDAwDz7ffvtt5o4caK+/PJL+3xSAAAA/xTXM29mzZo1tWDBAp07d05xcXFatGiRWrdubT9usVjUr18/TZkyxWHi65xYLBYlJSU5fJzhfHLuAdT1tCuoDRs2aOTIkSpWrJg6deokq9UqwzB09uxZxcXFqXTp0kpISNDy5cslXZmrqV69eoqIiFDfvn3VsmVLVatWTa+88oq+/PJLFS9eXJJUunRpLV++XG+99Va2EUqGYSg9PV1bt25VRkaGSpUqJX9//xxHMlWpUkXnz5/XihUrFBERoXPnzum+++5T7dq1Vbp0aR04cEA///yzYmJiVKFCBTVv3jzPVfoAACgsXBJCNWvWTElJSZozZ44kKSoqSq1atZLZbFZCQkKO/4ju379f3bt319SpUxUSEqKUlJR8vb4HAABwu7ieeTP79u2rlJQUBQcHq1KlSgoNDbWv5iZdec6qWrWqfcRPXm7VnJqlfb2v3agA7Qpi586d6tSpk3r37q3SpUsrKytLX375ZbaRS1cZhqHMzEw9++yz2r17t8qWLatXX31VBw4c0MKFC1WxYkUFBQXJ29tblSpVUq1atVSmTPZJ1WfOnKlatWopMDBQU6dO1dtvv6277rpL/9fenYfHdPZ/HH9PdiQRW2IXj1YtsW8hVLShVKu1VW0VW6uqKFKltba2WopQWvtOUaq2qKfaoqitaqc0CLX0IZLINjOZ3x/55dSYWKqSWD6v65rrMufc95z7nDNmvvnOvSxevJhjx47ZlT1z5gyvvvoqefPm5fXXX2fSpEm0bduWypUrM3/+fEqXLk1ISAg7duwgNDSUAQMGaHJyERF5JGTZnFAzZ86kR48e5M2bl2+++YYxY8YAkCtXLg4ePOhQ58svv+TGjRt06NABLy8vvLy8KFOmTGY3XURERCTD3M+8mZMmTcLHx4czZ85w9uxZLBYLYWFhQOqPeNOnT2fatGn3dPzMmlOzevHcFMjpgek2+01AgZweVC9+517y96NQoUJMmTKF7t27A/DVV1/x2muvYbVa0x2OZ7VacXZ25vjx45QtW5YzZ85Qrlw5atSowdatW4mKimLevHkEBgYSGRnJn3/+SUBAgN0xL1++zLBhwxgxYgRTpkwhX758TJ06lZkzZ9K+fXtGjx5tV97Dw4PAwECaNm3Km2++Sbdu3ejcuTOurq7MnTuXyMhIIiMjCQ0NpUiRIjRs2PCBXycREZGMkGUzGTZp0oRTp04xb948jh49aiSUbDYbFStWdCj/2WefYbPZ7B4Py+ouIiIiIg/C/cybuWjRIsLCwihatChFihRh1KhRzJo1C5vNxptvvsknn3xCwYIF7+n4mTWnprOTiSEvp8Z+tyai0p4PebkMzk63S1PdP19fX9q2bWs8T5snq1y5cly+fJk//vjDGI538OBBQkNDcXJy4qeffuLrr79m0KBBVK9e/Z5XdQZYs2YNnTp1omzZslSoUIGNGzcyduxYihYtyqeffsqMGTPsyvv5+TF79myeffZZDh48yJAhQ4DUnnG30sTkIiLyKMnSb638+fPTuHHjh2aSTBEREZGsdD/zZqakpHD58mXj+cWLF7FarZw9e5Zt27YRFhaGj48PPj4+nD17lvLly7N48eIMPY970TCgANPaVcbX277nV/6cHkxrV5mGAY5D2h4km81+5b1du3bh5uZGSkqKMTSvePHi9OjRg5MnT9KsWTMqVqxI7ty5ad26NT/++OM9HcdqtdKlSxdGjhwJpCaSFi9eTNeuXQFITk7mwIEDnD592hhSt2PHDjw9PQkNDSUlJcXo2QbQsmVLChcuTOHChZkwYYLDeYiIiDzMXLK6ASIiIiKS6uZ5Mzt27Ogwb6aXl5fD3D916tRh9OjRODs7k5yczJgxY2jSpAmFChXijz/+sCtbu3Ztli5dmm6v86zQMKAAQU/lpdzQTQDM7ViNOk/ny5AeULdKSUnBx8fHYXtSUhLJycl224oXL07t2rUJCwujcuXKuLu788ILLzBq1Cjc3NywWCwkJibi7++PxWIhOTmZy5cvk5ycTGLinSdXT0pKolGjRlSoUIHg4GAAAgMD2b59O9WqVbMrm5CQwPLly41yQ4cOJSkp6b6vgYiISGZTEkpERETkIZE2b2br1q0JCwvDycmJH374AUidN3P//v0OCaRPPvmEmJgY3n//fWJjY3nhhReYNGkSLi4u+Pv7O7x+4cKF77pKXkaZufU0M7faJ8Zs/N2Tp//K3zClM1NUlzrF6VLnPw+0LVWqVGHjxo0O2wsVKkR0dLTdNhcXF/r06WO3LSIi4q7HcHNzu2tPpYIFCzoMwTSZTA4JKIAVK1bYDZEcOnToXdsgIiLyMFESSkREROQhkjZv5t69ewkMDDSmLbhdMsPHx4f58+ff02tn9XyasYkWLsbcvmfQpZj0e/XEJloyqkmPlHz58mV1E0RERP4VJaFEREREHjJp82Y+brw8XMjv7XFf9UREROTRp290EREREckUXer854EPqxMREZFHh9Z0FRERERGRx1+K9e9/n/nZ/rmIiGQKJaFEREREROTxdmQNTK3+9/NFLWBiQOp2ERHJNBqOJyIiIiKZ4+cpsGPqP69X8x2o1ePBt0eeDEfWwFdvALdM7h/zZ+r21+ZDmSZZ0jQRkSeNklAiIiIikjmSYiH2wv3Vk3/MZrNx/fp1fHx8sropWSfFChv745CAgv/fZoKNH0CpxuDknMmNExF58mg4noiIiIhkDncv8Cp4y6PA3/u9CqSzv2BqvQzQqVMn+vbta7etYMGCTJ8+3aFsSkoKCQkJ2Gx/JzOCgoJYu3atXZn4+HiHuvXq1cPLy4u8efOm+3B1dWXevHn33O5p06ZRtWrVdPcNHz6c/v37A3Djxg1y5cqFxWLh+++/p2/fvnTv3p02bdrQqFEjtmzZcs/HfGSd+Rli7pT4tEHM+dRyIiKS4dQTSkREREQyR60ejsPqEmNgdJHUfzcJhxLPZVqPFHd3d9zc3Oy2eXl54eHh4VD2yJEj1K9fHzc3N0wmEwAXL16kc+fOZMuWDUhNQuXJk4f9+/fb1XV1dSU8PJzQ0NB02xEcHIy7u7vxvHPnzsyZMwcnJydsNhtNmzZlxYoVdq/n6enp8Dp169blt99+w2azsWzZMiNh1rhxY4KDg4mOjmbixIl4enoa5/DYi7v0YMuJiMi/op5QIiIiIpI1smCyaJvNRkJCAikpKTg7O+Pi4kJSUhIJCQkAuLm5pZuECggI4OzZs5w+fZrIyEgiIyMJDAxk3rx5xvPff/+dvXv3OtR1cbH/3XfFihUcOXLEbpuz89+JN3d3dwYOHIjFYmHMmDHptic9mzZt4v3336d3795ERkZy/PhxANatW4ebmxvZsmXDy8vryUlAAXj6PdhyIiLyrygJJSIiIiKZL22y6Ng/7benTRadQYmoqKgoSpQogb+/P7NnzyY8PJzixYvTo0dqD620xNTNw+7ShIeHU7NmTWrXrk3t2rXZv38//fr1o3bt2gQFBREYGMjJkycd6t2a9BkyZAgRERG3LePkZB+iu7i4YLFYbntOafvc3d0xmUxMnDgRf39/nnnmGaP+ra/5xChWC7wLArdLvJnAu1BqORERyXAajiciIiIimSsLJ4suUqQIFy5cICUlhSJFitC1a1eGDh1qV2bnzp0MGjSIiIgIihYtSlRUFLNnz8bNzY1mzZoZ5S5cuED16tUpWbKksW3lypUULFjQbuhdej2PihQp8o/aXb9+fX766SdMJhM2m42UlBSjh1VKSgopKSlG2d69ezN06FASExONoYJWq5X58+ezdu1aEhMTMZlMBAQE8N133/2jdjxynJyh4Zj/Xx3PhP177v/vS8PRmpRcRCSTPKE/iYiIiIhIlnkIJov++uuvuXDhAhs3bqR9+/Z2SZzq1avz9NNP07BhQ6Kjo/Hy8qJWrVoEBQURFBREXFwcn332GT179qRTp07kyZOHiIgISpcuTVBQEAEBAfZnc0uvqqtXr1KwYME7lrnV999/j9VqxWKx8MUXX1C3bl0sFgsWiwWr1WpX9taeUABms5kuXboQGRlJxYoVWbJkyeOfgEpTpgm8Nh+88ttv9y6Yur1Mk6xpl4jIE0g9oUREREQkc2XxZNGJiYl89NFH+Pv7U6NGDb777jv69OnDxIkTgdThcEuWLKFq1ao0a9aMiIgIQkJCSEhIwN/fn8uXL/PMM88wd+5cxowZg7e3N2FhYTz11FOULVvW4Xg3J4mio6O5ePEiJUqUuG2Z9NxpHqdb96XXE+ratWt4e3vf8RiPtTJN4D/Bf0+C33ZFpk6CLyIiqdQTSkREREQyVxZPFt2rVy+KFClC48aNyZUrFytXrqR58+Z2ZXLkyMGSJUsICAggKSkJgGzZsrF3716OHz9OmzZtcHNz49NPP2XPnj3UrFmTOnXq8M033zgcLzk52fh3REQE5cuXx8/Pj127dgGQM2dOh0TSyJEjcXFxoX///vd8XoULF2b8+PFMnz4df39/SpUqhbe3N3nz5uXChQsOva+eODcnnIrVUgJKRCQLqCeUiIiIiGSutMmiY/4k/XmhTKn7M2Cy6G3btrF27Vr27NnDiBEjAChdunS6ZStWrMjkyZON5x07duTnn3/mxIkTAOTJk4eePXsycuRIfHx8qFq1Km3btmXXrl12PaI2btyIs7MziYmJjBgxgh49enDq1ClCQkLo1q0bK1aswNXV1e7YAwcO5JNPPmHcuHH8+uuv93RuUVFR7N69mxs3bhAcHMyqVauoXLkyxYoVIyAggJ49e/6TSyUiIvLAqSeUiIiIiGSutMmiAcdVyzJ2sujatWtz/PhxChQoYMyxdDOLxWLXc+lm7dq1o2/fvkyYMIHo6Gh69+5N586dOXr0KH369GHZsmX897//dRiS5+bmxtWrV2ncuDGFChWiS5culChRgh07drBmzRqeffZZzp49a5Q3m8129dN6Yt1NXFwcoaGhrFy5EoB9+/bxwgsv8NNPPxEdHU21atXu6XVEREQyipJQIiIiIpL5snCyaE9PTyA14ZSQkGC3z2w2p5uE+uWXX1i2bBlDhw7FYrGQM2dOYx4ns9nM2rVr+c9//sO8efM4deqUUe/YsWMMGjSIp556ioIFC7JixQqcnFJD8ICAAH755Rdy585NpUqV2LBhA5A6rK5QoUIAvPfeeyxevNiuLbebxLxly5Z2vbeGDx/OG2+8QVhYGG+99ZYx5M9qtd51DioREZGMoOF4IiIiIpI1sniy6JiYGFxc7MPhuLg4h55HZrOZUaNGUb58eY4dO4a3tzfvvfces2bNYvjw4bi6ujJv3jwiIyP54IMPiIqKokSJElitVjp37ozJZGLVqlU899xzDm3ImTMna9asoXfv3nh4eAAwaNAgY7+zszPOzvbXw2w2k5iY6PBaAwYMoEaNGkayyWQy4erqSkJCAmFhYUa5xMTEdOuLiIhkNCWhRERERCRz/DwFdky9ZeNNvXrWvIvj8Dyg5jtQq8cDb86yZcscth09etRIBqVxdXVl1apVdtvefvttOnToQMWKFY1t/v7+LF261Hju7OzM999/j7u7+x3b4ezsTHh4+D23u3v37nTv3t1h+7PPPuuwrV+/fnTq1MnunLZu3XrPxxIREXmQlIQSERERkcyRFAuxF26/P/bP29fLJN7e3vdUrmTJkvdU7m4JqIxmMpnIkydPlrZBREQkjZJQIiIiIpI53L3Aq+D91RMREZFHnpJQIiIiIpI5avXIkGF1IiIi8mjQ6ngiIiIiIiIiIpLh1BNKRERERDLFvMPzmH9k/j+u90aZN+hQtkMGtEhEREQyk5JQIiIiIpIpbphvcDn+8n3VexzExqZOsO7lpTmuRETkyaQklIiIiIhkihyuOfDN7mu3zWazcSXhCgD5suXDZDKlWy+jtWvXjsDAQHr0uP2cVQsWLGDDhg0sXrzYbnuzZs1o2LAhb7755h2P8c0339CvXz/Onj2Lm5vbXdsUHBxMdHQ0Pj4+DvsSExO5cOECZ8+eTbdes2bN6Nmz512PISIikpmUhBIRERGRTNGhbAeHYXWxSbHUWloLgGG1hlGrYC2cnZwztB3Jyck4OTnh4vJ3KOzh4YGHh4ddObPZDICrqysAFovF2Ga1WklOTsbDwwNXV1dcXV2x2WwkJibi7u6Ok5Pj1KsRERG88cYb95SAAnB3d8dqtWKxWBz2Wa1WsmXLlm69bNmy2fW2CgkJYceOHbi6upKQkEDPnj0ZO3bsPbVBRETkQVISSkRERESyxOYzmxn1yyjjeff/dscvux8fVP+AkGIhGXbcNm3asH79ertkUEJCAosXL6Zfv37GtuTkZN58800++ugjzp8/z4ULF4iLi2P//v0kJCTQuXNnnJ2diYqKYvv27YwbN46EhAS2bNlCsWLFAAgNDWX+/Pl2SakJEyY4tCklJYUhQ4YwZMgQY5vVauXtt9+mcuXKDuX//PNPu7amtdfFxQVnZ2dMJhMWiwWTyYSHhwcLFiygWbNm9OjRwyHZJiIiklmUhBIRERGRTLf5zGb6/NAHGza77ZfjL9Pnhz5MCJ6QYYmoFStWOGzr1q0bgYGBhIaGOuzbu3cvX3/9NUeOHCEqKooVK1bQtWtXjh49CsDrr79Ow4YN062bLVs2Bg8ezNChQ+/YptDQUIfkUNu2bTlz5gwbN25Mt84777xj9/y1115j9+7dXLp0iZ07d/Lhhx8yadIkIymVxtk5Y3uaiYiI3I6SUCIiIiKSqawpVkb/MtohAQVgw4YJE2N+GUO9IvUybGjerUPt7qRKlSpUqVKFuXPnsnHjRkaMGMHzzz/PqVOnALhy5QqbN282Ek1Wq5V9+/aRL1++f5TwSSv77rvvsn37dnx8fMiePftty1ssFpYuXUrdunUZO3Ysq1ev5tq1a+TLl49x48YZSbH58+cr8SQiIg8FJaFEREREJFPtu7yPS/GXbrvfho2L8RfZd3kf1fJXy5A2LFq0iNGjR3Py5ElKly4NwLZt2xg3bhynT5+mb9++fPzxxw71Tp06Ra1atdiwYQPe3t52PYxMJhPx8fGkpKSkmzyqWbMmp06dMvZdvHiR8ePHO/RoCg8PB2DOnDlcv379tudgMpno1auX3bZ169ZhtVo5dOgQu3btokaNGpjN5nueh0pERCQjOc6YKCIiIiKSga7EX3mg5e5HaGgox44do3LlykyePJlDhw5x6NAhNm3aRLZs2RwSQz/++CNz5szh4MGDNGrUCFdXV1JSUhxe12Qy4eLiku4qf+7u7nz++edERkYSGRlJYGAg7u7ut23j6NGjsVqt+Pv74+/vz+DBg8mfPz/+/v7kyZOHDz74wKHO1KlT8fb25syZMzRv3pz//e9/xMTEkCNHxq8wKCIicjfqCSUiIiIimSpf9nwPtNy/MXz4cPr27cuuXbtwc3OjT58+9OrVi/z58xtlJk6cyLBhwwgICODVV19l0KBBvPXWW2zYsMFhFbySJUvi6enJkSNH/nXbnJycmDt3rpFASkhIYMKECTg5OWGxWByOvX79ei5dukRQUBCNGzemTJkyREdHc+7cObvzERERySpKQomIiIhIpqrsWxm/7H5cjr+c7rxQJkz4Zfejsq/jqnAPWqNGjVi5ciWdOnWibNmynD17lgULFtiV6dixI2+88QZr1qwxJgmfMmUKH374If369cPX1ze13SYTJ06cuO3qc4mJiXTv3t1Y1e7ixYu0bNnytm0LDAwkV65cxvC93377jXr16uHq6orFYsHPz88om5KSQu/evXn//fdZu3YtAMOGDSM2Npbo6Gj8/f3v7wKJiIg8QEpCiYiIiEimcnZy5oPqH9Dnhz4O+0ykDmPrX71/hk1KfqvBgwdTtmxZli1bxq5duxwmK8+ZM6dDHVdXV86cOUP79u2JiIi4p+Ps3Lnzntu0c+dODhw4YDeXk9lsZsuWLUYPqOTkZLZv305QUBBOTk7MmjWLWrVqGUkogFWrVhEUFORwTnFxcbi6ut5xOKCIiMiDpjmhRERERB4ihw4dolq1auTKlYuwsDBsNseeQjez2Wy8/fbb5M6dGx8fH0JDQ0lISDD2Dxs2jNy5c+Pu7k7Tpk2JjY3N6FO4JyHFQpgQPAHf7L522/2y+zEheAIhxUIy9PhxcXF89913vPXWW9StW5ePP/6Y0aNH8+KLL9KmTRsWLVrEgQMHuHDhAgDbt29nx44ddsmcqVOn0rp1a86fP88PP/wA4LAK3c33Ij0XL17kt99+4/z583avXaFCBSIiItixYwc7d+5k586d5MyZk++//56dO3eyY8cOtm7dSvXq1Y06derUwdnZGavVitVqJTo6msGDB9tNXm4ymUhOTmbLli08//zz9339RERE7oeSUCIiIiIPiaSkJF5++WWqVKnCnj17OHLkCHPnzr1jnQULFnD8+HH279/P1q1bOXz4MKNGjQJSV4BbtGgRGzdu5PDhwxw9epTRo0dnwpncm5BiIaxustp4/vnzn7Ox+cYMT0B1796dPHnyMGrUKKpWrcrhw4fp3bs3ffv25eTJk9SuXZsFCxZQr149evfuDcAXX3zBvn376Ny5s/E6efPmJTQ0lD179vDqq6/Svn17hx5Hrq6utx2eBxhzOEVHR9OoUSMgdW6nOnXq8Prrr1O/fn1CQkIICQnBZDLRpEkTQkJCqF+/Pq+88gpBQUHMmDHD7jUTExNJTExk9uzZ1K1bl4YNGxr7KlWqxIwZM3j33Xd55ZVX/u2lFBER+Uc0HE9ERETkIbFhwwauX7/OhAkTyJ49OyNHjuSdd96hY8eOt63zyy+/0KJFC4oVKwbAq6++yuHDhwE4d+4c8+bNM3rLtGrVit27d2f8idzGvMPzmH9kvt22m3t6Dfl5SLqryr1R5g06lO3wwNoxduxYxo0bZ8y1dDMvLy+6d+9O9+7dgdQhcADz5893KJvmlVdeITo6Ot1906dPv2NbKlSo4NA77cUXX+TFF1+8Y7072bJli/Fvq9Vqt69Tp0506tTpvl9bRETk31ASSkREROQhceDAAQIDA43kSPny5e+6ylrZsmVZsGABzZs3JzExkaVLl9KnT+pcSx988IFd2ePHj/P000/f9rWSkpJISkoynsfExNzvqaTrhvkGl+Mv33b/lYQrt633IKWtNncvbu3Z9Ki5dXigiIhIVlISSkREROQhERMTQ/HixY3nJpMJZ2dnrl27Rq5cudKt06VLF6ZNm0b+/PkBePnll+nQwbHX0IkTJ1i1ahX79u277fFHjRrFsGHD/uVZ3F4O1xwOc0Ddaz0RERF59CkJJSIiIvKQcHFxcVitzMPDg/j4+NsmoSZNmoSPjw9nzpzBZDLx1ltvERYWxvjx440yKSkpdOrUiS5dulC2bNnbHn/AgAFGLypITYoVKVLkX57V3zqU7fBAh9WJiIjIo0UTk4uIiIg8JHLnzs2VK/ZD0mJjY3Fzc7ttnUWLFhEWFkbRokUpUqQIo0aNYtasWXZlPv74Y65evcrYsWPveHx3d3e8vb3tHiIiIiIPipJQIiIiIg+JatWqsWPHDuP5H3/8QVJSErlz575tnZSUFC5f/nuepYsXL9pNRv3tt98yYcIEVq5cme5E3CIiIiKZRcPxRERERB4Szz77LDExMcyZM4eOHTsycuRIQkJCcHZ2Jjo6Gi8vL4eJpuvUqcPo0aNxdnYmOTmZMWPG0KRJEwCOHj1K69at+fzzzylSpAhxcXE4OTllWTLqf3PmcnXu3H9cL3doKHk6hj7w9oiIiEjmUhJKRERE5CHh4uLCzJkzad26NWFhYTg5OfHDDz8AkCtXLvbv30/FihXt6nzyySfExMTw/vvvExsbywsvvMCkSZMA+PLLL7lx4wYdOnQwJisvVqwYkZGRmXhWf0uJi8Ny6dJ91ctMw4YNo0SJErRr1y5TjysiIvK403A8ERERkYdIkyZNOHXqFPPmzePo0aOUKVMGAJvN5pCAAvDx8WH+/PlcvnyZhIQEVq9eTd68eQH47LPPsNlsdo+sSkABOHl64uLnZ//w/Xu1PBdfX8f9fn44eXo+sDZERUXh5uZG1apVyZcvH127duX8+fPGfrPZzOeff263SmGauXPnUrly5X/dhhIlSnDs2LG7lmvXrh1Dhw512F60aFE2btz4r9shIiKS2dQTSkREROQhkz9/fho3bpzVzXjg8nR0HFZnjY3lRLXqABT45GNyBAVhumXI4YPk5uaGr68ve/bsoUGDBjRo0ICSJUuyf/9++vTpw65du4iOjuatt94CIDExkeXLl1OpUiWyZcuGl5eX8VoLFy6kY8eO5MiRA6vVioeHh8PE8sOHD2fq1KnGqocxMTHExcVRq1Yt3N3dcXd3x2KxEBcXR3R0tF1dm82W7jnkypULFxeF8SIi8uhRTygRERERyRIxmzZxuvFLxvNzb77F78+HELNpU4Yd08kpNfxNTk5mz549NGrUiKCgIL799lu++uor/Pz8WLlyJYcOHeLQoUMcPXqU8uXLYzabcXZ2xmQyYbPZSE5OxsPDg0aNGhEdHc2WLVvw8PBwON7gwYO5dOkSJ06coGbNmrzyyiuUKFGCESNGkCNHDiIiIoiKirJLQJnNZqxWKyaTyWir1WolOTkZwNgOEB8fz40bNzLseomIiDxISkKJiIiISKaL2bSJ8716Y7lpZT8Ay6VLnO/VO0MTUQDbtm2jXLlyeHp60qpVK1xcXJgzZw7R0dGkpKSwevVqVq9ezeHDh/n666/Jnz8/Xbp0YefOnRQtWpS2bdsaSak0t04aD5CQkMDChQspX748Pj4+zJo1C5vNRsOGDRk7diz169enZcuWTJs2jdOnTwMwdOhQChcuzPLly/nss88oUqQI//3vfylWrBiFCxfmwIEDvPbaa/j7+1OyZElmz56doddKRETkQVE/XhERERHJVDarlUsjR0F6w81sNjCZuDRyFF7PP59hQ/PWrVtHnTp1sFgsdOjQgRs3blCqVCliYmJYv3492bNnZ8+ePVSqVInw8HBatmxJs2bNuHr1qjFZ/Ndff51u4ulmnTp14vDhw0yYMIHGjRtjMpmwWCwkJyfz4osvUqtWLTZs2MCWLVt4/fXXARgxYgRDhw7F19eXXr16GfNC/fnnn3z11Ve0atWKBg0asHTp0gy5NiIiIhlFPaFEREREJFPF79mL5eLF2xew2bBcvEj8nr0Z1oaWLVuydOlSVq9eTYECBejSpQsnT54kX758vPTSS7Ro0YJy5coZSab4+Hg2b95MYmIiixYtAlKHzbm5ud3xODNnzuTAgQN8++23zJkzB0hNMvn6+rJq1SrCwsIIDQ1l3rx55MqVy6i3fv16oqOj2bZtGyNHjjS2T506FRcXF9asWWP0nBIREXlUqCeUiIiIiGQqyy2Td//bcvcjMDCQOnXqcO7cOcLDw9mwYQOe/78K37lz54iJieHatWvkz58fgAULFhi9mAYNGoSTkxNxcXHkyJHjtsdYu3YtPXv2xM3NjQsXLvDtt98yfPhwpk+fTvXq1bl+/ToJCQmUKlWKlJQUXnjhBcLDw7HZbIwaNYoCBQpQuHBhRo4cycsvv2zMHVW2bFmefvppOnbsyPfff3/X3lhPpJ+nwI6pt2y8qeddeBXAhIOa70CtHhnZMhGRJ5p6QomIiIhIpnLJl++BlrtfzzzzDFu2bAHsJ/ueMWMGEydOZNu2bUDqCnkjR46kffv2eHp68sUXX2A2mzl37pyRpErPSy+9xOnTp2nVqhWxsbEMGTKEFStW0LBhQ2bPns1ff/2F1WqlUaNGnDhxgvDwcAAmT57M9evXqVevHv7+/nz77bcUKFCAt956i8GDBwPQpUsXzGYzb7/9NlarNaMu0aMrKRZiL9zy+PPv/bF/prP/Qmo9ERHJMEpCiYiIiEimyl61Ci7584MpnZ4oACYTLvnzk71qlQxrQ3h4OAMHDiQkJMRuu81mY+PGjezZs4dWrVoBMG7cOAoUKEBwcDAA9evX54033uD48eOUKVPmjse5cuUKkydPJiQkhN9//52XX36ZnTt3MmnSJBo0aEDTpk1ZvXo1Bw8eNOpcvXqV0aNHG4mxoKAgWrduTYkSJWjevDmQOgn68uXL2bRpEy+++OKDuiyPD3cv8Cr4zx/uXlndchGRx5qG44mIiIhIpjI5O+M3cADne/VOHRF18/zk/5948Rs4IEMmJbf9/2ToaXM+BQcHs3TpUlJSUoDUuZ8A9u3bx8SJE5kyZQotWrSgadOmHD161Hid2NhYNm/ezIQJExyO8ddff5E3b14SExNp1qwZHTp0AKBChQq0bduWY8eO8euvvzJixAi+++47Jk2aROPGjdm0aROlSpVi8ODBRpIJ4MyZM8THx7Nw4UK74xQqVIgff/yRc+fOPfDr9Mir1UPD6kREHkLqCSUiIiIimc67QQMKTZqISz5fu+0ufn4UmjQR7wYNMuS4ZrMZwOjZdP36dWbOnMmqVasYMGAA06ZNw2KxEBAQwKVLl2jatClOTk6ULVsWq9VqDH376KOPqF+/PoUKFQJSh/MlJycDULp0aU6cOMHBgwfx8PBgzJgxpKSkYLVauXbtGl27dmXWrFk4OTlhtVpp0qQJvXr1olu3bthsNmOOJ4vFgsVi4emnn2b79u0UL14cSE2kpSXTihUrRu3atTPkWomIiDxoSkKJiIiISJbwbtCA/6xbazwv8uUXPPXfzRmWgILUxM7NvvzyS55//nkuXbpE9erVWbduHc2bN6dIkSIULlyYggULcvbsWSB1bqjExER+//13Nm3axMSJE43XKVq0KADlypWjYMGCPP3001SrVo1Nmzbh7u5OUlISZrOZWrVq8e2331K3bl2SkpKMxFXfvn357rvv7OamMpvNJCYmOpxDQkICSUlJD/rSiIiIZDgNxxMRERGRTPG/OXO5Oneu/Ubb32Px/vxoULrzROUODSVPx9AH0oaiRYsSFRVlPA8LCzP+3bRpU5o2bXrbuh06dDCG1h06dMhuVbp8+fJx4cIFhzppSaXPPvsMFxcX3NzcjLml2rVrR7t27Yyyrq6udnVXrlyZbjtOnDhx2zaKiIg8zJSEEhEREZFMkRIXh+XSpdvut1y+fNt6DxvnfzhfVfbs2TOoJSIiIo8OJaFEREREJFM4eXri4ud3X/VERETk0acklIiIiIhkijwdH9ywOhEREXn0aGJyEREREblvtpvmdJLHg+6piIhkFCWhREREROQfS5tEOz4+PotbIg9a2j29daJ0ERGRf0vD8URERETkH3N2dsbHx4fL/z+ZePbs2Y2V4OTRZLPZiI+P5/Lly/j4+PzjyddFRETuRkkoEREREbkv+fPnBzASUfJ48PHxMe6tiIjIg6QklIiIiIjcF5PJRIECBfD19cVsNmd1c+QBcHV1VQ8oERHJMFmWhDp06BAdO3bk999/p0uXLnz66ad37cK9YsUK+vbti9lsZvz48bRu3TqTWisiIiIit+Ps7KzEhYiIiNxVlkxMnpSUxMsvv0yVKlXYs2cPR44cYe7cuXesc+jQIdq2bcugQYOIiIhg8ODBHD9+PHMaLCIiIiIiIiIi/0qWJKE2bNjA9evXmTBhAiVKlGDkyJHMmjXrjnVmzpxJvXr16NKlC+XKlaNHjx4sWLAgk1osIiIiIiIiIiL/RpYkoQ4cOEBgYCDZs2cHoHz58hw5cuSudZ577jnjefXq1dm7d2+GtlNERERERERERB6MLJkTKiYmhuLFixvPTSYTzs7OXLt2jVy5ct1THW9vby5cuHDbYyQlJZGUlGQ8v379uvE6GSExLjZDXjcjxSQmZnUT/jFTBt2/f0v3P3Po/j84uv8Pju5/5sio+58WF9hstgx5/Udd2nXJqPhJREREHj3/Jn7KkiSUi4sL7u7udts8PDyIj4+/bRLq1jpp5W9n1KhRDBs2zGF7kSJF7rPVjx/Hq/MIGD06q1vw2ND9f7Lp/j/ZdP8dxcbGkjNnzgw9xqMoNjY1yar4SURERG51P/FTliShcufOzaFDh+y2xcbG4ubmdsc6V65cuefyAwYMoE+fPsbzlJQUrl69Sp48ee66Ct+TICYmhiJFinDu3Dm8vb2zujmSyXT/n2y6/0823X97NpuN2NhYChYsmNVNeSgVLFiQc+fO4eXl9cDjJ70XJSvofSdZQe87yQoZ+b77N/FTliShqlWrxowZM4znf/zxB0lJSeTOnfuOdXbs2EHnzp0B2L9/P4UKFbpteXd3d4feVj4+Pv+u4Y8hb29vfRA+wXT/n2y6/0823f+/qQfU7Tk5OVG4cOEMPYbei5IV9L6TrKD3nWSFjHrf3W/8lCUTkz/77LPExMQwZ84cAEaOHElISAjOzs5ER0djtVod6jRv3pylS5dy8OBB4uLimDx5Mi+88EJmN11ERERERERERO5DliShXFxcmDlzJj169CBv3rx88803jBkzBoBcuXJx8OBBhzoVKlSgV69eVK1alUKFCuHs7Ez37t0zu+kiIiIiIiIiInIfsmQ4HkCTJk04deoUe/fuJTAwkDx58gB3nl19xIgRtG3blvPnz1O3bt07zgkld+bu7s6QIUMchizKk0H3/8mm+/9k0/2Xh4Xei5IV9L6TrKD3nWSFh/V9Z7JpTWIREREREREREclgWTIcT0REREREREREnixKQsl9S68T3dy5c7ly5UoWtEYeRjabjejo6Kxuhvy/2NhYYmNjs7oZ8i8MGzaMhQsXZnUzRB4aikXkYaUYSECxl9y/xznmUxLqIbV7927q1atHfHy83fZLly7h4+OTbp3ExETeffddrl+/DsCNGzfSXWkwTXJyMiaTidy5c5M3b947Ptzc3Jg0aZJd/caNG7Nq1Srj+W+//cY777yD2Wy+z7N+8nTq1Im+ffvabStYsCDTp093KJuSkkJCQoJdwB0UFMTatWvtytz6ngGoV68eXl5et72/rq6uzJs3757bPW3aNKpWrZruvuHDh9O/f38g9T2YK1cuLBYL33//PX379qV79+60adOGRo0asWXLlns+5uOuXbt2TJky5Y5lFixYQJs2bRy2N2vWjC+//PKux/jmm294+umnSU5Ovqc2BQcHU7FiRYKDgx0egYGBFC1a9Lb1Jk+efE/HkL9FRUXh5uZG1apVyZcvH127duX8+fPGfrPZzOeff07x4sUd6s6dO5fKlSv/6zaUKFGCY8eO3bVcu3btGDp0qMP2okWLsnHjxn/dDnk4KBaRjKQYSDFQVlPsJVnlSY/5smxicrmzatWq8corrxAVFUXJkiUZP348NpuNhIQErFYr48aNAyBfvnx06NABSP2QPHjwIF5eXgCULFkSZ2dnnJxSc43nz59n0KBBDB48GAA3Nzfc3d3Zt28f/v7+ACQkJJAtWzajHcnJybi5ufHSSy/h6elpbL9w4QI7d+5k/vz5xraFCxditVqpVauWsa1QoUL89NNPODs7Z8BVevS5u7s7TLDv5eWFh4eHQ9kjR45Qv3593NzcMJlMAFy8eJHOnTsb9ywlJYU8efKwf/9+u7qurq6Eh4cTGhqabjuCg4PtJqzr3Lkzc+bMwcnJCZvNRtOmTVmxYoXd6938fkhTt25dfvvtN2w2G8uWLTOCxcaNGxMcHEx0dDQTJ07E09PTOIcnUXJyMk5OTri4/P0R7OHh4XDf0/6IcnV1BcBisRjbrFYrycnJeHh44OrqiqurKzabjcTERNzd3Y3/9zeLiIjgjTfeuOdFHdzd3bFarVgsFod9VqvV7rPiZtmyZTM+hwBCQkLYsWMHrq6uJCQk0LNnT8aOHXtPbXiSuLm54evry549e2jQoAENGjSgZMmS7N+/nz59+rBr1y6io6N56623gNQ/9pcvX06lSpUcrvnChQvp2LEjOXLkwGq14uHh4dAzZPjw4UydOtX4vx8TE0NcXBy1atXC3d0dd3d3LBYLcXFxDr/m3246yVy5ctm9r+XRplhEMpJiIMlMir0Uez1MnvSYTz2hHjKnTp3Cx8eHYsWKMWHCBGrUqEFUVBQffvghlStXplq1ari5uREYGIi7u7uR8Y6Pj2f8+PHMmTOH2NhYduzYwfnz5zl79iyRkZFMnDiRatWqMWDAALvjubi4cPLkSZYuXQrAxIkTadGihbF/yJAhfPjhhwB2wVt4eDi9e/cmJiaGwYMHc+nSJaZPn06pUqWIjIzkjz/+wM/Pjw4dOijou0VaAJ+SkoKzszMuLi4kJSWRkJAApH4opReABQQEcPbsWU6fPk1kZCSRkZEEBgYyb9484/nvv//O3r17Here+gGxYsUKjhw5Yrft5vvk7u7OwIEDsVgsjBkzJt32pGfTpk28//779O7dm8jISI4fPw7AunXrcHNzMz40n/Tgq02bNnh7e+Pj42M8FixYQM+ePe225cyZk7CwMP766y8OHDjAhQsXiIuLY//+/ezatYvKlStTrlw5IiIiGDRoEAEBAZQtW5Zz584ZxwoNDTWCriVLljBhwgRcXFwcHk5OTgwbNsyunVarlbfffptx48Y5PNLeHzdLTk423tcmkwmLxWJ8GS5YsIDo6Gi6du16z++nJ01a8JqcnMyePXto1KgRQUFBfPvtt3z11Vf4+fmxcuVKDh06xKFDhzh69Cjly5fHbDYb19xmsxkBcqNGjYiOjmbLli3pXvO0z+4TJ05Qs2ZNXnnlFUqUKMGIESPIkSMHERERREVF2QUjZrMZq9Vq/B9OTk42gnLA7v92fHw8N27cyMArJhlFsYhkFMVAioGyimIvxV4Pkyc95tPPlQ+ZEiVKGDf/iy++YO7cuRQuXBhXV1dq1apFYmIirq6u1K5dG4vFYnyx9u3blz59+lC8eHHefPNN/vjjD7777jsg9cuvdevWrFmzxsjq38zd3Z1evXpRs2ZNfvjhBxo3bkzVqlXZsmULP/zwA/369ePAgQNG+SNHjrB48WIOHz7M0KFDOXv2LB07duSdd95h165dLF68mJiYGAC6dOmSwVfs0RMVFUWNGjVwcXHhr7/+ws3NjVmzZtGoUSNmzZplBGU2m80hUAkPD2fp0qXGrykHDx6kX79+fPLJJ0Zgt2TJEp555hm7ere+zpAhQ+jSpQtlypRJt8ytv+S4uLjYvd9ulbbP3d0dk8nExIkTmTt3rpE5T/uilVQ3/6Kaplu3bgQGBqb7S+3evXv5+uuvOXLkCFFRUaxYsYKuXbty9OhRAF5//XUaNmyYbt1s2bIxePDgdLvR3iw0NNThS6tt27acOXPmtl1t33nnHbvnr732Grt37+bSpUvs3LmTDz/8kEmTJhlflmn0x+Cdbdu2jXLlyuHp6UmrVq2Ii4tjzpw5REdHk5KSwurVqwHw9/fn5MmTdOvWDavVSmJiIkWLFiUwMJA2bdrc9ZonJCSwcuVKhg8fTr169Zg6dSplypShYcOG5M+fn/r161OjRg2ee+45XnjhBf7zn/8wdOhQZs+ezdWrV/Hw8GDatGksWLDA+CP//PnzvPbaa3h7e2OxWOjfvz/vvvtuZl06eUAUi0hGUQwkWUWxl2Kvh9GTGvMpCfWQMpvNjB8/no8++ghw/EJMYzKZ2Lp1K19++SVVqlThs88+4/r16/z666+kpKQwfvx4Fi9ezIoVK3jnnXdo3bo1H330kV0AWLRoUQYNGsQ777zDr7/+yjfffMOOHTsYOHAgJ06c4KWXXmLOnDlG+X79+nH9+nWCgoKIiopi3759fPPNN3Tr1o1jx45Rr1493N3d+fnnn/Wlm44iRYpw4cIFUlJSKFKkCF27dnX4ktq5cyeDBg0iIiKCokWLEhUVxezZs3Fzc6NZs2ZGuQsXLlC9enVKlixpbFu5ciUFCxa0+1JM71e3IkWK/KN2169fn59++snIvKekpBgBWUpKCikpKUbZ3r17M3ToUBITE41uw1arlfnz57N27VoSExMxmUwEBAQYf6A8aW7t7n0nVapUoUqVKsydO5eNGzcyYsQInn/+eU6dOgXAlStX2Lx5s/E+slqt7Nu3j3z58v2joCOt7Lvvvsv27dvx8fEhe/bsty1vsVhYunQpdevWZezYsaxevZpr166RL18+xo0bZ7wH58+fr+DnH1i3bh116tTBYrHQoUMHbty4QalSpYiJiWH9+vVkz56dPXv2UKlSJcLDw2nZsiXNmjXj6tWr/PDDDwB8/fXXd73mnTp14vDhw0yYMIHGjRsbv6AmJyfz4osvUqtWLTZs2MCWLVt4/fXXARgxYgRDhw7F19eXXr16Ge+5P//8k6+++opWrVrRoEEDo0eLPNoUi8iDphhIMVBWUuwlD5snNeZTEuohNXbsWKKjo2nVqhWQ+gWaP39+bDYbsbGx+Pj4YLFYCAgIoFatWuzevZs8efIQHBzMokWL2Lp1K/379ycgIIAffviBnDlzGnM7REREOARlb7/9NtOnT6dhw4Z4eHgwevRoSpYsSfv27e3GyQNMnjwZb29vxowZY3TX79mzJ+fOnePzzz/H09OThIQEFi5cSOfOnSlQoECmXrtHxddff82FCxfYuHEjp06dYt68ecY9qV69OidOnKBhw4b8/PPPeHl5GWN2IXV8+YwZMxgwYABVq1bl6NGjLF68mN69e+Pj40OOHDnsjnXrWN6rV69SsGDBO5a51ffff28EcjNnzmThwoXGh9+tdW/9FRBSv/i7dOnChAkTaNiwIR988AHBwcH3drEeQ4sWLWL06NGcPHmS0qVLA6m/howbN47Tp0/Tt29fPv74Y4d6p06dMr4ovL297YJrk8lEfHw8KSkp6QYwNWvW5NSpU8a+ixcvMn78eIdf1cLDwwGYM2eOMblwekwmE7169bLbtm7dOqxWK4cOHWLXrl3UqFEDs9l8z3MhCLRs2ZJ27dpRsWJF3n77bYKDgzl58iQBAQG89NJL5M6dm6SkJCPgiI+PZ/PmzZQpU4ZFixbRtm3be7rmM2fOJHv27HTr1o3Lly/TqVMnRowYga+vL6tWrWL9+vXMnz/f4Vfe9evXEx0dzbZt2xg5ciQDBw4EYOrUqbi4uLBmzRpOnz7Nf/7znwy5PpJ5FItIRlEM9GTHQFlFsZc8bJ7UmE8/DT2Etm7dypAhQ/D09KRJkyZYrVZsNhsXL17kzJkz+Pr6Eh0dbawI4uzsTKVKlQgLC6NLly7Uq1ePZ555hn79+rFy5Upy5swJgK+vL2vXruXjjz92+FUwbVK93bt3k5ycTL58+fDx8Un318OnnnqKy5cvs27dOsLCwrh06RLPPfcc5cqVw9fXl2PHjvHzzz9z+PBhihYtSt26de+4Ms6TKDExkY8++gh/f39q1KjB3r176dOnj7HfycmJJUuWYLPZaNasGdmzZyckJISqVavSokULRowYQa5cuZg7dy4tW7Zk3LhxtG3blqeeeoq6des6rNpy8/WPjo7m4sWLlChR4rZl0nOnOQxu3XfrfAgA165dw9vb+47HeJKEhoZy7NgxKleuzOTJk40x35s2bSJbtmwOwcmPP/7InDlzOHjwII0aNcLV1dXul9c0JpMJFxeXdO+Xu7s7n3/+ud18Grf+YXez0aNHY7Va8ff3x9/fn8GDB5M/f378/f3JkycPH3zwgUOdqVOn4u3tzZkzZ2jevDn/+9//iImJcfijQG4vMDCQOnXqcO7cOcLDw8mePbsxCe65c+eIjIzk2rVrRvkFCxYYv2gNGjSIJUuW3PWar127lnLlylG6dGmWLFlifB7lypWL6tWr07NnT1atWkWpUqUoWbKk0b3aZrMxatQoChQoQOHChRk5ciQHDx5kw4YNREdHU7ZsWRo3bkzHjh31uf+IUywiGUUxkGQVxV7ysHlSYz4loR4y+/fvp0mTJnTs2BFfX18sFgsrV65M9wMPUt8cZrOZN998kwMHDlCwYEH69+/PsWPHWLRoEcWKFcPPzw8PDw/8/f0JCAhI99fAGTNmEBAQQO7cuQkPD2fEiBFUqFCBxYsXOyzdeObMGV599VXy5s3L66+/zqRJk2jbti2VK1dm/vz5lC5d2liRITQ0lAEDBqg76C169epFkSJFaNy4Mbly5WLlypU0b97crkyOHDlYsmQJAQEBJCUlAaljzPfu3cvx48dp06YNbm5ufPrpp+zZs4eaNWtSp04dvvnmG4fj3bwsbEREBOXLl8fPz49du3YBkDNnTocvzpEjR+Li4mIsNXwvChcuzPjx45k+fTr+/v6UKlUKb29v8ubNy4ULFxx+eZTU1Sr69u1r3KM+ffrQq1cv8ufPb5SZOHEir776KikpKbz66qsMGjSI9957j+LFixtBStqqUiVLlqRSpUoPpG1OTk7MnTuX0aNHM3r0aBISEpgwYQKjR49m0qRJDn8Yrl+/nkuXLhEUFETjxo3p3Lkz0dHRnDt3zu585O6eeeYZY/num/9vzpgxg4kTJ7Jt2zYg9Y+5kSNH0r59ezw9Pfniiy8wm813veYvvfQSp0+fplWrVsTGxjJkyBBWrFhBw4YNmT17Nn/99RdWq5VGjRpx4sQJ4xfayZMnc/36derVq4e/vz/ffvstBQoU4K233jJWO+vSpQtms5m3335bf/Q/ohSLSEZSDCRZTbGXPEyexJhPw/EeMoUKFWLKlCmULVuWbt268dVXX5EnTx5CQ0PT7QJfqlQpnJ2dOX78OGXLluXMmTOUK1eOGjVqsHXrVgA2btzI6NGjjW7Dt7p8+TLDhg3jv//9L2azmd9++42PP/6Y3377jVGjRjF69Gi78h4eHgQGBlKpUiVKly5NQEAARYsW5auvvmLu3LlG9+KhQ4fi5OREw4YNM/KSPXK2bdvG2rVr2bNnDyNGjAAwugTfqmLFisaqQwAdO3bk559/5sSJEwDkyZOHnj17MnLkSHx8fKhatSpt27Zl165dlC1b1qi3ceNGnJ2dSUxMZMSIEfTo0YNTp04REhJCt27dWLFihcP4+IEDB/LJJ58wbtw4fv3113s6t6ioKHbv3s2NGzcIDg5m1apVVK5cmWLFihEQEEDPnj3/yaV6IjRq1IiVK1fSqVMnypYty9mzZ1mwYIFdmY4dO/LGG2+wZs0aY6LKKVOm8OGHH9KvXz98fX2B1C+uEydO3HYFlMTERLp3706/fv2A1C7hLVu2vG3bAgMDyZUrl9GF/LfffqNevXq4urpisVjw8/MzyqakpNC7d2/ef/99o2fEsGHDiI2NJTo62gjU5O7Cw8MZOHAgEydOtNtus9nYuHEj+fPnp2/fvlitVsaNG0eBAgUIDg7m0KFD1K9fH4BWrVrRpEmTOx7nypUrTJ48mZCQEH7//XeGDh3KqlWrmDRpEg0aNCBPnjysXr2aTp06Ua5cOSB1GMvo0aNZvnw5gBH0lihRgubNm/Pxxx/j7OzM8uXLCQoK4sUXXyQiIuLBXyTJUIpFJKMoBpKHgWIveVg8qTGfklAPGV9fX9q2bWt84eXJkweAcuXKsXXrVuLi4ihTpgwXL17kjz/+YN26dTg5OfHTTz8Bqd2JT506xbVr1+550sU1a9YYH8I2m41PP/2UsWPHUrRoUT799FM8PDxo2rSpUd7Pz4/Zs2dz4MABvv/+e5YvX86cOXPS7YKqyUAd1a5dm+PHj+Pp6YnVanVYajVtkrj0tGvXjpo1a3Ljxg06depEeHg40dHRjBs3juXLlxMSEsKJEyfsgi9IXfL4ypUrvP766xQqVIguXbrg5OTEjh07aN68Odu2bWPZsmUULVoU+HvixjRpv0LeTVxcHKGhoTz33HMEBwezb98+BgwYwJdffkl0dDTVqlW718v0RBk8eDBly5Zl2bJl7Nq1yyEYThvGcjNXV1fOnDlD+/bt7/kDf+fOnffcpp07d3LgwAG7MeZms5ktW7bYLSu7fft2goKCcHJyYtasWdSqVcsIhABWrVpFUFCQwznFxcXh6up6xy7pT5q0+UNatGhBuXLlCA4OZunSpUbvk/j4eAD27dvHxIkTmTJlCi1atKBp06bGaj0AsbGxbN68mQkTJjgc46+//iJv3rwkJibSrFkzOnToAECFChVo27Ytx44d49dff2XEiBF89913TJo0icaNG7Np0yZKlSrF4MGDjYADUnujxMfHs3DhQrvjFCpUiB9//NFuyWp5dCgWkYyiGEgeFoq9JCs96TGfklAPqVsnOUzrMnzzChzFixenR48enDx5kv79+3P69Gn++OMPnnrqKUJDQylfvvxdj2O1WunSpYuRKTeZTCxevNjYn5yczPHjxzl9+rTRjX3Hjh3UrVuXp59+mnbt2hEWFmaUb9mypfHBFhMTY7dP/pY21tdisZCQkGC3z2w2pxuA/fLLLyxbtoy1a9fy3nvvkTNnTqPbo9lsZu3atbz55pu0bt2avHnzGvMdpA2HmDx5Mk2aNGH69OnGF1lAQAC//PILbdq0oVKlSixcuJBGjRpRuHBh8ubNC8B7773nMATjdhN4tmzZ0u6Xy+HDh5MtWzbCwsJ46623jD8OrFbrEz9MJy4ujh07drBixQo2bdrExx9/jNVq5cUXX+S5556jcePGBAQEkC9fPgoWLMj27dvZsWOHXUAxdepU1q5dy/nz5zl58iTguCzrre+vW128eJHLly9z/vx5u67kFSpUICIigrx58xr3LW/evHz//fd4enpis9mIj4+3C5Tq1KkD/H1/o6OjGTx4MNOnTzfKmEwmkpOT2bJlC2PGjDG6GMvff/gUKFCAAgUKcP36dWbOnMmuXbsYMGAA06ZNMyaBvnTpEhaLBScnJ8qWLcuhQ4eM/1MfffQR9evXp1ChQsDf1xxSexxs376d69ev4+HhwZgxYwgLC8NqtXLt2jW6du3K2rVruXz5MlarlSZNmhhLAm/ZssV4f1ksFiwWC08//TTbt283zsFmsxmfD8WKFaNYsWKZdv3kwVMsIhlBMZBioKyi2Eux18PiSY/5lIR6SKWkpODj4+OwPSkpyeHLuXjx4tSuXZuwsDAqV66Mu7s7L7zwAqNGjcLNzQ2LxUJiYiL+/v7GL0yXL18mOTmZxMTEO7YjKSmJRo0aUaFCBaNre2BgINu3b3f4RSchIYHly5fbdYG/11+PnlQxMTHGEr9p4uLiHK6b2Wxm1KhRlC9fnmPHjuHt7c17773HrFmzGD58OK6ursybN4/IyEg++OADoqKiKFGiBFarlc6dO2MymVi1ahXPPfecQxty5szJmjVr6N27t9GVeNCgQcZ+Z2dnhy9Xs9mc7ntnwIAB1KhRw/jiNJlMuLq6kpCQYPdHQGJi4l3fe4+z7t27M2vWLIKCgmjdujWfffaZ0e36zTffZMGCBSxYsIBffvmFkJAQvvrqK7744guOHj3K2LFjjdfJmzcvoaGhfPPNN3To0IH27ds7/Orl6up62y7iAJcuXaJ27dqUKlWKRo0aAanzCwwePNhhngyTyUSTJk3sehXExMTQtWtXunbtamxLu7+zZ8+mbt26dsNgKlWqRP/+/Vm8eLHDBKBPult7BHz55Zc8//zzrFmzhoiICNasWcPYsWOJjIzk+vXrJCcns3fvXvLkyWNc899//51NmzYZcwsAxq/75cqVo2DBgjz99NOYTCY2bdqEyWQiKSkJs9lMrVq1+Pbbb6lbty4LFy40vmv69u1Lz5497d4Lt/sMSEhI0Of+Y0SxiGQkxUCSmRR7KfZ6mDzpMZ/Jdrc1SUXu0ZUrV/D29lYXz38pJiYGDw+Puy61eeLECeLj46lYseIdyyUlJWXpPbHZbFy9etUYziFw48YNTCZTukv53spsNjsEN48Sq9WqyYAz2T+95vHx8bi4uGgpZ3ksKBZ5tCkGkoyi2EseR49qzKcklIiIiIiIiIiIZDjN1CgiIiIiIiIiIhlOSSgREREREREREclwSkKJiIiIiIiIiEiGUxJKROQmNpst3eWhRURERCR9ip9E5F4pCSUij42JEyfy2muvAakrmwC8+OKLbN68mePHjxur6KQFST169KBgwYI4Ozvj7+9Pnjx58PLy4uWXX8ZisRAdHQ1A+/btmT59eqafj4iIiEhGU/wkIplJSSgReWy4u7uTLVs2ALp3706VKlXYsWMHPXr0oEWLFhw/fpyqVavSoEEDAKZMmcLRo0fx9fUlMjKSESNG0KJFCyIiIti7dy/16tUDIFu2bFruW0RERB5Lip9EJDO5ZHUDRET+rfj4eHbv3s3p06e5fPkymzdvZtKkSWTPnp3p06dTv359PD09+fTTTxk/frxdXbPZjKurq8Nruru7G4GTk5MTJpMpU85FREREJDMofhKRrKAklIg88uLi4liyZAn79+8nNjaW5cuXU7ZsWby9valYsSIzZ840yvr5+REeHk7p0qVZvHgxycnJxMTEMHToUPbs2UNUVBQDBw7k+eefz8IzEhEREclYip9EJCsoCSUijzxfX1+mT59OgwYNKF26NF988QUA3t7e7Nmzx65s7969cXV1JTk5mWvXrnHhwgU8PT2Jjo4mISHB2G42m7HZbFlxOiIiIiIZTvGTiGQFzQklIo+Fs2fP8t///peTJ08yZcoUIPUXvqpVq9o9lixZgslkokqVKkybNg0PDw+6dOnCxIkTadGiBVWrVmXatGl4eXmRlJQEwPXr13F2ds7K0xMRERF54BQ/iUhmU08oEXksfPzxxxQqVIjChQvz5ZdfUr58eVxdXenWrZtduWXLlhkrt7Rq1YrY2FjmzZsHpK76cvToUa5cuUJQUBC//vorVapU4ejRo3zwwQdZcVoiIiIiGUbxk4hkNpNN/SVF5BG3bt063nzzTXr16sWRI0cYPHgwfn5+7N69G4AZM2aQK1cuWrRoAUCZMmXw9fXlxx9/pGrVquTIkQNI/eXv1VdfpWnTprzzzjtA6i+Enp6e5M6dO2tOTkRERCQDKH4SkaygJJSIPPJiY2M5fPgwv/76Kzt37mTu3Ll06NCBgwcP4uTkxNmzZ8mePTt58+YFwGKxEBERgZ+fH7lz5yYhIcFYySU+Ph4XFxfc3NwASExM5LnnnmP9+vVZdn4iIiIiD5riJxHJChqOJyKPPC8vLwIDA/n111+NbTNmzMDFxYWjR49Sv3596tati81mY86cOSQlJeHh4QHA1atX7V6rXbt21K5d26EbuoiIiMjjRPGTiGQFTUwuIo8lJycnFi1aROPGjZkzZw4zZszgwoULvPrqq/zvf//DZDKRkpJyz69ntVq12ouIiIg81hQ/iUhGUxJKRB4bZrOZpKQkoqKiKFKkCKtXr2bz5s288MILuLm5sX79ekqWLEm5cuX4/PPPcXd3x9vbGx8fH+OxZs0a+vfvb7fNy8sLd3d3Tp06ldWnKCIiIvJAKX4SkcykOaFE5LEUFxeHp6dnuvtu3LhhTKYpIiIiIqkUP4lIRlMSSkREREREREREMpyG44mIiIiIiIiISIZTEkpERERERERERDKcklAiIiIiIiIiIpLhlIQSEREREREREZEMpySUiIiIiIiIiIhkOCWhREREREREREQkwykJJSIiIiIiIiIiGU5JKBERERERERERyXBKQomIiIiIiIiISIb7P2Xe7s8ROAGPAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "最佳模型: 随机森林\n",
      "最佳准确率: 0.9676\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n=== 步骤5：模型训练和对比 ===\")\n",
    "\n",
    "# 准备数据（使用TF-IDF特征）\n",
    "X = X_tfidf\n",
    "y = df['评价']\n",
    "\n",
    "# 分割数据集\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, test_size=0.2, random_state=42, stratify=y\n",
    ")\n",
    "print(f\"训练集大小: {X_train.shape}\")\n",
    "print(f\"测试集大小: {X_test.shape}\")\n",
    "\n",
    "# 定义多个模型\n",
    "models = {\n",
    "    '神经网络': MLPClassifier(random_state=42, max_iter=1000),\n",
    "    '朴素贝叶斯': MultinomialNB(),\n",
    "    '支持向量机': SVC(random_state=42),\n",
    "    '随机森林': RandomForestClassifier(random_state=42)\n",
    "}\n",
    "\n",
    "# 训练和评估模型\n",
    "model_results = {}\n",
    "\n",
    "for name, model in models.items():\n",
    "    print(f\"\\n训练{name}模型...\")\n",
    "    \n",
    "    # 训练模型\n",
    "    model.fit(X_train, y_train)\n",
    "    \n",
    "    # 预测\n",
    "    y_pred = model.predict(X_test)\n",
    "    \n",
    "    # 计算准确率\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    \n",
    "    # 交叉验证\n",
    "    cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')\n",
    "    \n",
    "    model_results[name] = {\n",
    "        'accuracy': accuracy,\n",
    "        'cv_mean': cv_scores.mean(),\n",
    "        'cv_std': cv_scores.std(),\n",
    "        'model': model\n",
    "    }\n",
    "    \n",
    "    print(f\"{name} - 测试集准确率: {accuracy:.4f}\")\n",
    "    print(f\"{name} - 交叉验证准确率: {cv_scores.mean():.4f} (±{cv_scores.std():.4f})\")\n",
    "\n",
    "# 可视化模型对比\n",
    "plt.figure(figsize=(12, 5))\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "model_names = list(model_results.keys())\n",
    "test_accuracies = [model_results[name]['accuracy'] for name in model_names]\n",
    "cv_means = [model_results[name]['cv_mean'] for name in model_names]\n",
    "\n",
    "x = np.arange(len(model_names))\n",
    "width = 0.35\n",
    "\n",
    "plt.bar(x - width/2, test_accuracies, width, label='测试集准确率', color='skyblue')\n",
    "plt.bar(x + width/2, cv_means, width, label='交叉验证准确率', color='lightcoral')\n",
    "\n",
    "plt.xlabel('模型')\n",
    "plt.ylabel('准确率')\n",
    "plt.title('模型性能对比')\n",
    "plt.xticks(x, model_names)\n",
    "plt.legend()\n",
    "plt.ylim(0, 1)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "for name, result in model_results.items():\n",
    "    plt.errorbar(name, result['cv_mean'], yerr=result['cv_std'], \n",
    "                fmt='o', capsize=5, capthick=2, label=name)\n",
    "\n",
    "plt.xlabel('模型')\n",
    "plt.ylabel('交叉验证准确率')\n",
    "plt.title('模型稳定性对比')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 选择最佳模型\n",
    "best_model_name = max(model_results.keys(), key=lambda x: model_results[x]['cv_mean'])\n",
    "best_model = model_results[best_model_name]['model']\n",
    "print(f\"\\n最佳模型: {best_model_name}\")\n",
    "print(f\"最佳准确率: {model_results[best_model_name]['cv_mean']:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e44d4be-0459-439c-a1e5-2c56b954c9da",
   "metadata": {},
   "source": [
    "## 详细的评估如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f4df624c-cd3e-41e9-91cb-0e72fb0ce8cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤6：详细评估 ===\n",
      "\n",
      "分类报告:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.97      0.98        96\n",
      "           1       0.98      1.00      0.99       120\n",
      "\n",
      "    accuracy                           0.99       216\n",
      "   macro avg       0.99      0.98      0.99       216\n",
      "weighted avg       0.99      0.99      0.99       216\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\n=== 步骤6：详细评估 ===\")\n",
    "\n",
    "# 使用最佳模型进行详细评估\n",
    "y_pred = best_model.predict(X_test)\n",
    "\n",
    "# 分类报告\n",
    "print(\"\\n分类报告:\")\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# 混淆矩阵\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n",
    "            xticklabels=le.classes_, yticklabels=le.classes_)\n",
    "plt.title('混淆矩阵')\n",
    "plt.xlabel('预测标签')\n",
    "plt.ylabel('真实标签')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7763c43-d12c-4e74-8974-bb836a1dbb3a",
   "metadata": {},
   "source": [
    "## 特征重要性分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "12be5894-40e6-41ae-a809-c932e7d87c21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤7：特征重要性分析 ===\n",
      "最重要的20个特征:\n",
      "    feature  importance\n",
      "430      屏幕    0.051063\n",
      "676      流畅    0.043592\n",
      "833      苹果    0.039921\n",
      "958      非常    0.035886\n",
      "336      喜欢    0.025422\n",
      "472      很快    0.025333\n",
      "506      感觉    0.023536\n",
      "523      手感    0.022604\n",
      "932      速度    0.022427\n",
      "106      不错    0.021703\n",
      "30       xr    0.021700\n",
      "793      续航    0.021540\n",
      "887      运行    0.020198\n",
      "724      电池    0.019856\n",
      "529      手机    0.019246\n",
      "664      没有    0.014913\n",
      "777      系统    0.014366\n",
      "393      好看    0.013882\n",
      "893      还是    0.013419\n",
      "366      外观    0.013070\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\n=== 步骤7：特征重要性分析 ===\")\n",
    "\n",
    "# 如果是随机森林，可以查看特征重要性\n",
    "if best_model_name == '随机森林':\n",
    "    importances = best_model.feature_importances_\n",
    "    feature_names = tfidf_vect.get_feature_names_out()\n",
    "    \n",
    "    # 获取最重要的特征\n",
    "    top_features = pd.DataFrame({\n",
    "        'feature': feature_names,\n",
    "        'importance': importances\n",
    "    }).sort_values('importance', ascending=False).head(20)\n",
    "    \n",
    "    print(\"最重要的20个特征:\")\n",
    "    print(top_features)\n",
    "    \n",
    "    # 可视化特征重要性\n",
    "    plt.figure(figsize=(10, 8))\n",
    "    plt.barh(range(len(top_features)), top_features['importance'])\n",
    "    plt.yticks(range(len(top_features)), top_features['feature'])\n",
    "    plt.xlabel('重要性')\n",
    "    plt.title('Top 20 重要特征')\n",
    "    plt.gca().invert_yaxis()\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2c896c2-b6c9-4ad7-b721-efb72717679b",
   "metadata": {},
   "source": [
    "## 情感分析运用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "266d2a7a-5bc1-4498-a5e5-43a450bad509",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤8：情感分析应用 ===\n",
      "\n",
      "测试评论情感分析:\n",
      "评论: 这个产品质量很好，非常满意！\n",
      "情感: 0\n",
      "置信度: 0.690\n",
      "--------------------------------------------------\n",
      "评论: 服务态度差，不推荐购买\n",
      "情感: 0\n",
      "置信度: 0.910\n",
      "--------------------------------------------------\n",
      "评论: 价格合理，物流快速\n",
      "情感: 0\n",
      "置信度: 0.990\n",
      "--------------------------------------------------\n",
      "评论: 包装破损，商品有瑕疵\n",
      "情感: 0\n",
      "置信度: 0.980\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n=== 步骤8：情感分析应用 ===\")\n",
    "\n",
    "def analyze_sentiment(comment, vectorizer, model, label_encoder):\n",
    "    \"\"\"分析单条评论的情感\"\"\"\n",
    "    # 文本预处理\n",
    "    cleaned = clean_text(comment)\n",
    "    # 分词\n",
    "    words = ' '.join(jieba.cut(cleaned))\n",
    "    # 向量化\n",
    "    X = vectorizer.transform([words]).toarray()\n",
    "    # 预测\n",
    "    prediction = model.predict(X)\n",
    "    # 获取概率（如果模型支持）\n",
    "    if hasattr(model, 'predict_proba'):\n",
    "        probabilities = model.predict_proba(X)[0]\n",
    "        confidence = max(probabilities)\n",
    "    else:\n",
    "        confidence = None\n",
    "    \n",
    "    return {\n",
    "        'comment': comment,\n",
    "        'sentiment': label_encoder.inverse_transform(prediction)[0],\n",
    "        'confidence': confidence\n",
    "    }\n",
    "\n",
    "# 测试几条示例评论\n",
    "test_comments = [\n",
    "    \"这个产品质量很好，非常满意！\",\n",
    "    \"服务态度差，不推荐购买\",\n",
    "    \"价格合理，物流快速\",\n",
    "    \"包装破损，商品有瑕疵\"\n",
    "]\n",
    "\n",
    "print(\"\\n测试评论情感分析:\")\n",
    "for comment in test_comments:\n",
    "    result = analyze_sentiment(comment, tfidf_vect, best_model, le)\n",
    "    print(f\"评论: {result['comment']}\")\n",
    "    print(f\"情感: {result['sentiment']}\")\n",
    "    if result['confidence']:\n",
    "        print(f\"置信度: {result['confidence']:.3f}\")\n",
    "    print(\"-\" * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "872184e7-e7c7-4fb7-b001-15526ee58014",
   "metadata": {},
   "source": [
    "## 交互式情感分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2990afc8-bcea-4fed-a740-683779441576",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== 步骤9：交互式情感分析 ===\n",
      "\n",
      "=== 情感分析系统 ===\n",
      "输入 'quit' 退出程序\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "\n",
      "请输入您对本商品的评价： good\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "分析结果:\n",
      "评论内容: good\n",
      "情感倾向: 0\n",
      "置信度: 1.000\n",
      "分析结果可信度很高\n",
      "😔 很抱歉给您带来不好的体验，我们会改进产品和服务\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "\n",
      "请输入您对本商品的评价： quit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "感谢使用情感分析系统！\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n=== 步骤9：交互式情感分析 ===\")\n",
    "\n",
    "def interactive_sentiment_analysis():\n",
    "    \"\"\"交互式情感分析\"\"\"\n",
    "    print(\"\\n=== 情感分析系统 ===\")\n",
    "    print(\"输入 'quit' 退出程序\")\n",
    "    \n",
    "    while True:\n",
    "        comment = input('\\n请输入您对本商品的评价：')\n",
    "        if comment.lower() == 'quit':\n",
    "            print(\"感谢使用情感分析系统！\")\n",
    "            break\n",
    "        \n",
    "        if not comment.strip():\n",
    "            print(\"请输入有效的评论内容\")\n",
    "            continue\n",
    "        \n",
    "        # 分析情感\n",
    "        result = analyze_sentiment(comment, tfidf_vect, best_model, le)\n",
    "        \n",
    "        # 输出结果\n",
    "        print(f\"\\n分析结果:\")\n",
    "        print(f\"评论内容: {result['comment']}\")\n",
    "        print(f\"情感倾向: {result['sentiment']}\")\n",
    "        \n",
    "        if result['confidence']:\n",
    "            print(f\"置信度: {result['confidence']:.3f}\")\n",
    "            \n",
    "            # 根据置信度给出建议\n",
    "            if result['confidence'] > 0.8:\n",
    "                print(\"分析结果可信度很高\")\n",
    "            elif result['confidence'] > 0.6:\n",
    "                print(\"分析结果可信度较高\")\n",
    "            else:\n",
    "                print(\"分析结果可信度一般，建议提供更多详细信息\")\n",
    "        \n",
    "        # 根据情感给出反馈\n",
    "        if result['sentiment'] == '好评':\n",
    "            print(\"😊 感谢您的好评！\")\n",
    "        else:\n",
    "            print(\"😔 很抱歉给您带来不好的体验，我们会改进产品和服务\")\n",
    "\n",
    "# 启动交互式分析\n",
    "interactive_sentiment_analysis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e08c68bc-285f-443c-8670-d2ef62ad6463",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
